sandboxedjs 0.1.7 → 0.1.8

package/dist/index.js

@@ -757,10 +757,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;
       }
@@ -6716,8 +6716,8 @@ var init_ffmpeg_core = __esm({
           };
           function handleMessage(data) {
             if (typeof data == "string") {
-              var encoder6 = new TextEncoder();
-              data = encoder6.encode(data);
+              var encoder7 = new TextEncoder();
+              data = encoder7.encode(data);
             } else {
               assert(data.byteLength !== void 0);
               if (data.byteLength == 0) {
@@ -10443,12 +10443,40 @@ function strerrorOf(e) {
 var EXIT_NOT_EXECUTABLE = 126;
 var EXIT_NOT_FOUND = 127;
 
+// src/kernel/binfmt.ts
+var MAGIC_BYTES = 256;
+var ExecFormatRegistry = class {
+  formats = [];
+  register(format) {
+    this.formats.push(format);
+    this.formats.sort((a, b) => (a.priority ?? 50) - (b.priority ?? 50));
+  }
+  registerAll(formats) {
+    for (const f of formats) this.register(f);
+  }
+  /** The handler claiming `head`, or null when the bytes match nothing. */
+  match(head2, path) {
+    for (const format of this.formats) {
+      try {
+        if (format.matches(head2, path)) return format;
+      } catch {
+      }
+    }
+    return null;
+  }
+  list() {
+    return this.formats.slice();
+  }
+};
+
 // src/kernel/kernel.ts
 var BUILTIN_INTERPRETER = "/proc/self/exe";
 var Kernel = class {
   vfs;
   procs = new ProcessTable();
   commands = new CommandRegistry();
+  /** Handlers for executable files that are neither built-ins nor scripts. */
+  formats = new ExecFormatRegistry();
   users;
   pod;
   bootTime;
@@ -10578,14 +10606,15 @@ var Kernel = class {
         const command = this.commands.get(builtinName);
         if (command) return { kind: "builtin", path: candidate, command };
       }
-      let head2 = "";
+      let bytes = new Uint8Array(0);
       try {
         if (this.vfs.permitted(st, R_OK, cred)) {
-          head2 = new TextDecoder().decode(this.vfs.readFile(real, cred).subarray(0, 256));
+          bytes = this.vfs.readFile(real, cred).subarray(0, MAGIC_BYTES);
         }
       } catch {
       }
-      if (head2.startsWith("#!")) {
+      if (bytes[0] === 35 && bytes[1] === 33) {
+        const head2 = new TextDecoder().decode(bytes);
         const lineEnd = head2.indexOf("\n");
         const line = (lineEnd >= 0 ? head2.slice(2, lineEnd) : head2.slice(2)).trim();
         const parts = line.split(/\s+/).filter(Boolean);
@@ -10595,6 +10624,8 @@ var Kernel = class {
         }
         if (parts.length) return { kind: "script", path: real, interpreter: parts };
       }
+      const format = this.formats.match(bytes, real);
+      if (format) return { kind: "binary", path: real, format, head: bytes };
       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"] };
@@ -10747,6 +10778,24 @@ var Kernel = class {
       proc.argv = [interp, ...interpArgs, resolved.path, ...proc.argv.slice(1)];
       return await this.dispatch(proc, depth + 1);
     }
+    if (resolved.kind === "binary" && resolved.format) {
+      const { format } = resolved;
+      if (format.run) {
+        const ctx = createContext({ argv: proc.argv, proc, kernel: this });
+        const previous = this._current;
+        this._current = proc;
+        try {
+          return await format.run(ctx, resolved.path);
+        } finally {
+          this._current = previous;
+        }
+      }
+      const lines = format.explain?.(resolved.head ?? new Uint8Array(0), resolved.path) ?? [
+        `${name}: cannot execute ${format.describe?.(resolved.head ?? new Uint8Array(0), resolved.path) ?? format.name} file`
+      ];
+      for (const line of lines) proc.stderr.write(line + "\n");
+      return EXIT_NOT_EXECUTABLE;
+    }
     proc.stderr.write(`${name}: cannot execute binary file: Exec format error
 `);
     return EXIT_NOT_EXECUTABLE;
@@ -13523,16 +13572,16 @@ sys	${fmt2(Math.floor(ms * 0.2))}
 function splitAliasWords(text) {
   const out = [];
   let current = "";
-  let quote2 = null;
+  let quote3 = null;
   for (let i = 0; i < text.length; i++) {
     const c = text[i];
-    if (quote2) {
-      if (c === quote2) quote2 = null;
+    if (quote3) {
+      if (c === quote3) quote3 = null;
       else current += c;
       continue;
     }
     if (c === "'" || c === '"') {
-      quote2 = c;
+      quote3 = c;
       continue;
     }
     if (c === " " || c === "	") {
@@ -14906,8 +14955,10 @@ function describeFile(ctx, abs, st, mime) {
   if (st.size === 0) return mime ? "inode/x-empty" : "empty";
   const bytes = ctx.vfs.readFile(abs, ctx.cred).subarray(0, 512);
   const magic = [...bytes.subarray(0, 4)];
-  if (magic[0] === 127 && magic[1] === 69 && magic[2] === 76 && magic[3] === 70) {
-    return mime ? "application/x-executable" : "ELF 64-bit LSB executable, x86-64";
+  const format = ctx.kernel.formats.match(bytes, abs);
+  if (format) {
+    if (mime) return format.name === "wasm" ? "application/wasm" : "application/x-executable";
+    return format.describe?.(bytes, abs) ?? `${format.name} executable`;
   }
   if (magic[0] === 31 && magic[1] === 139) return mime ? "application/gzip" : "gzip compressed data";
   if (magic[0] === 80 && magic[1] === 75) return mime ? "application/zip" : "Zip archive data";
@@ -22544,16 +22595,16 @@ async function loadFactory() {
   const path = await nodeBuiltin("path");
   const require2 = createRequire(path.join(process.cwd(), "index.js"));
   const wasmPath = require2.resolve("@ffmpeg/core/wasm");
-  const wasm = await fs.readFile(wasmPath);
+  const wasm2 = await fs.readFile(wasmPath);
   const module = await Promise.resolve().then(() => (init_ffmpeg_core(), ffmpeg_core_exports));
-  return { factory: module.default, wasm: new Uint8Array(wasm) };
+  return { factory: module.default, wasm: new Uint8Array(wasm2) };
 }
 function getCompiled() {
   compiled ??= (async () => {
-    const { factory, wasm } = await loadFactory();
-    const bytes = wasm.buffer.slice(
-      wasm.byteOffset,
-      wasm.byteOffset + wasm.byteLength
+    const { factory, wasm: wasm2 } = await loadFactory();
+    const bytes = wasm2.buffer.slice(
+      wasm2.byteOffset,
+      wasm2.byteOffset + wasm2.byteLength
     );
     return { factory, module: await WebAssembly.compile(bytes) };
   })();
@@ -22630,6 +22681,1019 @@ var ffprobe = defineCommand({
 function ffmpegCommands() {
   return [ffmpeg, ffprobe];
 }
+
+// src/runtime/wasi-preview1.ts
+init_errno();
+init_mode();
+init_path();
+var E = {
+  SUCCESS: 0,
+  ACCES: 2,
+  AGAIN: 6,
+  BADF: 8,
+  BUSY: 10,
+  EXIST: 20,
+  FAULT: 21,
+  INVAL: 28,
+  IO: 29,
+  ISDIR: 31,
+  LOOP: 32,
+  MFILE: 33,
+  NAMETOOLONG: 37,
+  NOENT: 44,
+  NOEXEC: 45,
+  NOMEM: 48,
+  NOSPC: 51,
+  NOSYS: 52,
+  NOTDIR: 54,
+  NOTEMPTY: 55,
+  NOTSUP: 58,
+  NOTTY: 59,
+  PERM: 63,
+  PIPE: 64,
+  ROFS: 69,
+  SPIPE: 70,
+  XDEV: 75,
+  NOTCAPABLE: 76
+};
+var ERRNO_MAP = {
+  EPERM: E.PERM,
+  ENOENT: E.NOENT,
+  EIO: E.IO,
+  EBADF: E.BADF,
+  EACCES: E.ACCES,
+  EBUSY: E.BUSY,
+  EEXIST: E.EXIST,
+  EXDEV: E.XDEV,
+  ENODEV: E.NOSYS,
+  ENOTDIR: E.NOTDIR,
+  EISDIR: E.ISDIR,
+  EINVAL: E.INVAL,
+  ENFILE: E.MFILE,
+  EMFILE: E.MFILE,
+  ENOSPC: E.NOSPC,
+  EROFS: E.ROFS,
+  ENOTEMPTY: E.NOTEMPTY,
+  ELOOP: E.LOOP,
+  ENOSYS: E.NOSYS,
+  ENAMETOOLONG: E.NAMETOOLONG,
+  EPIPE: E.PIPE,
+  ENOTSUP: E.NOTSUP,
+  ESPIPE: E.SPIPE
+};
+var FT = {
+  UNKNOWN: 0,
+  BLOCK_DEVICE: 1,
+  CHARACTER_DEVICE: 2,
+  DIRECTORY: 3,
+  REGULAR_FILE: 4,
+  SOCKET_STREAM: 6,
+  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 RIGHT_FD_READ = 1n << 1n;
+var RIGHT_FD_WRITE = 1n << 6n;
+var RIGHTS_ALL = (1n << 63n) - 1n;
+var WHENCE_SET = 0;
+var WHENCE_CUR = 1;
+var WHENCE_END = 2;
+var SIZEOF_DIRENT = 24;
+var SIZEOF_FILESTAT = 64;
+var SIZEOF_IOVEC = 8;
+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 WasiPreview1 = class {
+  memory = null;
+  fds = /* @__PURE__ */ new Map();
+  nextFd = 3;
+  opts;
+  now;
+  randomFill;
+  /** Set once `proc_exit` has been seen, so the caller can tell exit 0 from a
+   * module that simply returned. */
+  exited = null;
+  constructor(opts) {
+    this.opts = opts;
+    this.now = opts.now ?? Date.now;
+    this.randomFill = opts.randomFill ?? ((buffer) => {
+      for (let i = 0; i < buffer.length; i++) buffer[i] = Math.floor(Math.random() * 256);
+    });
+    const blank = { pos: 0, data: new Uint8Array(0), dirty: false, fdflags: 0, rights: RIGHTS_ALL };
+    this.fds.set(0, { kind: "stdin", path: "/dev/stdin", ...blank, data: opts.stdin ?? new Uint8Array(0) });
+    this.fds.set(1, { kind: "stdout", path: "/dev/stdout", ...blank });
+    this.fds.set(2, { kind: "stderr", path: "/dev/stderr", ...blank });
+    const preopens = opts.preopens ?? { "/": "/", ".": opts.cwd };
+    for (const [name, path] of Object.entries(preopens)) {
+      const fd = this.nextFd++;
+      this.fds.set(fd, { kind: "dir", path, ...blank, preopen: name });
+    }
+  }
+  /** Give the host access to the instantiated module's memory. */
+  bind(instance) {
+    const memory = instance.exports.memory;
+    if (!(memory instanceof WebAssembly.Memory)) {
+      throw new Error("wasm module does not export its memory; not a WASI command module");
+    }
+    this.memory = memory;
+  }
+  /* ── memory access ──────────────────────────────────────────────────────
+   * Re-derived on every use: a module that grows its memory detaches the old
+   * ArrayBuffer, and a cached view would silently start reading zeroes. */
+  get view() {
+    if (!this.memory) throw new Error("wasi host used before bind()");
+    return new DataView(this.memory.buffer);
+  }
+  get bytes() {
+    if (!this.memory) throw new Error("wasi host used before bind()");
+    return new Uint8Array(this.memory.buffer);
+  }
+  readString(ptr, len) {
+    return decoder7.decode(this.bytes.subarray(ptr, ptr + len));
+  }
+  /** Scatter/gather list, as `fd_read` and `fd_write` take. */
+  iovecs(ptr, count) {
+    const view = this.view;
+    const out = [];
+    for (let i = 0; i < count; i++) {
+      const at = ptr + i * SIZEOF_IOVEC;
+      out.push({ base: view.getUint32(at, true), len: view.getUint32(at + 4, true) });
+    }
+    return out;
+  }
+  /* ── path handling ──────────────────────────────────────────────────────── */
+  /**
+   * Resolve a path supplied by the module against a directory descriptor.
+   *
+   * The result is confined to the descriptor's subtree: `..` that would climb
+   * out of a preopen is rejected with ENOTCAPABLE, which is WASI's own answer
+   * and stops a module reaching a directory it was never granted.
+   */
+  resolveAt(dirfd, path) {
+    const dir3 = this.fds.get(dirfd);
+    if (!dir3) return E.BADF;
+    if (dir3.kind !== "dir") return E.NOTDIR;
+    if (path === "") return E.NOENT;
+    const abs = isAbsolute(path) ? normalize(path) : resolve(dir3.path, path);
+    if (dir3.path !== "/" && !contains(dir3.path, abs) && abs !== dir3.path) return E.NOTCAPABLE;
+    return { path: abs };
+  }
+  errnoOf(e) {
+    if (isSysError(e)) return ERRNO_MAP[e.code] ?? E.IO;
+    return E.IO;
+  }
+  filetypeOf(mode) {
+    switch (mode & 61440) {
+      case S_IFREG:
+        return FT.REGULAR_FILE;
+      case S_IFDIR:
+        return FT.DIRECTORY;
+      case S_IFLNK:
+        return FT.SYMBOLIC_LINK;
+      case S_IFCHR:
+        return FT.CHARACTER_DEVICE;
+      case S_IFBLK:
+        return FT.BLOCK_DEVICE;
+      case S_IFSOCK:
+        return FT.SOCKET_STREAM;
+      default:
+        return FT.UNKNOWN;
+    }
+  }
+  /** Write a 64-byte `filestat` for `path`. */
+  writeFilestat(ptr, path, follow) {
+    try {
+      const st = follow ? this.opts.vfs.stat(path, { cred: this.opts.cred }) : this.opts.vfs.lstat(path);
+      const view = this.view;
+      view.setBigUint64(ptr, BigInt(st.dev), true);
+      view.setBigUint64(ptr + 8, BigInt(st.ino), true);
+      view.setUint8(ptr + 16, this.filetypeOf(st.mode));
+      view.setBigUint64(ptr + 24, BigInt(st.nlink), true);
+      view.setBigUint64(ptr + 32, BigInt(st.size), true);
+      view.setBigUint64(ptr + 40, BigInt(Math.round(st.atimeMs * 1e6)), true);
+      view.setBigUint64(ptr + 48, BigInt(Math.round(st.mtimeMs * 1e6)), true);
+      view.setBigUint64(ptr + 56, BigInt(Math.round(st.ctimeMs * 1e6)), true);
+      return E.SUCCESS;
+    } catch (e) {
+      return this.errnoOf(e);
+    }
+  }
+  /** Persist an open file's buffer back to the filesystem. */
+  flush(fd) {
+    if (!fd.dirty) return E.SUCCESS;
+    try {
+      this.opts.vfs.writeFile(fd.path, fd.data, { cred: this.opts.cred });
+      fd.dirty = false;
+      return E.SUCCESS;
+    } catch (e) {
+      return this.errnoOf(e);
+    }
+  }
+  /* ── the import object ──────────────────────────────────────────────────── */
+  /**
+   * The `wasi_snapshot_preview1` namespace, plus `wasi_unstable` for older
+   * toolchains — the two differ only in `fd_seek`'s argument order, which is
+   * handled by the alias below.
+   */
+  get imports() {
+    const preview1 = this.syscalls();
+    return {
+      wasi_snapshot_preview1: preview1,
+      wasi_unstable: {
+        ...preview1,
+        // preview0's fd_seek took (fd, offset, whence) with whence as the last
+        // u32 but numbered CUR=0/END=1/SET=2 — the reverse of preview1.
+        fd_seek: (fd, offset, whence, out) => preview1.fd_seek(fd, offset, whence === 0 ? WHENCE_CUR : whence === 1 ? WHENCE_END : WHENCE_SET, out)
+      }
+    };
+  }
+  /* eslint-disable @typescript-eslint/no-unused-vars */
+  syscalls() {
+    const vfs = this.opts.vfs;
+    const cred = this.opts.cred;
+    return {
+      /* ── process ──────────────────────────────────────────────────────── */
+      args_sizes_get: (countPtr, bufSizePtr) => {
+        const view = this.view;
+        view.setUint32(countPtr, this.opts.args.length, true);
+        view.setUint32(
+          bufSizePtr,
+          this.opts.args.reduce((sum, a) => sum + encoder6.encode(a).length + 1, 0),
+          true
+        );
+        return E.SUCCESS;
+      },
+      args_get: (argvPtr, bufPtr) => {
+        const view = this.view;
+        const bytes = this.bytes;
+        let cursor = bufPtr;
+        this.opts.args.forEach((arg, i) => {
+          view.setUint32(argvPtr + i * 4, cursor, true);
+          const encoded = encoder6.encode(arg);
+          bytes.set(encoded, cursor);
+          bytes[cursor + encoded.length] = 0;
+          cursor += encoded.length + 1;
+        });
+        return E.SUCCESS;
+      },
+      environ_sizes_get: (countPtr, bufSizePtr) => {
+        const pairs = this.envPairs();
+        const view = this.view;
+        view.setUint32(countPtr, pairs.length, true);
+        view.setUint32(
+          bufSizePtr,
+          pairs.reduce((sum, p) => sum + encoder6.encode(p).length + 1, 0),
+          true
+        );
+        return E.SUCCESS;
+      },
+      environ_get: (environPtr, bufPtr) => {
+        const pairs = this.envPairs();
+        const view = this.view;
+        const bytes = this.bytes;
+        let cursor = bufPtr;
+        pairs.forEach((pair, i) => {
+          view.setUint32(environPtr + i * 4, cursor, true);
+          const encoded = encoder6.encode(pair);
+          bytes.set(encoded, cursor);
+          bytes[cursor + encoded.length] = 0;
+          cursor += encoded.length + 1;
+        });
+        return E.SUCCESS;
+      },
+      proc_exit: (code) => {
+        this.exited = code;
+        throw new WasiExit(code);
+      },
+      proc_raise: (_signal) => E.NOTSUP,
+      sched_yield: () => E.SUCCESS,
+      random_get: (ptr, len) => {
+        const target = new Uint8Array(len);
+        this.randomFill(target);
+        this.bytes.set(target, ptr);
+        return E.SUCCESS;
+      },
+      /* ── clocks ───────────────────────────────────────────────────────── */
+      clock_res_get: (_id, ptr) => {
+        this.view.setBigUint64(ptr, 1000000n, true);
+        return E.SUCCESS;
+      },
+      clock_time_get: (_id, _precision, ptr) => {
+        this.view.setBigUint64(ptr, BigInt(Math.round(this.now() * 1e6)), true);
+        return E.SUCCESS;
+      },
+      /* ── descriptors ──────────────────────────────────────────────────── */
+      fd_close: (fd) => {
+        const entry = this.fds.get(fd);
+        if (!entry) return E.BADF;
+        const status = this.flush(entry);
+        this.fds.delete(fd);
+        return status;
+      },
+      fd_datasync: (fd) => {
+        const entry = this.fds.get(fd);
+        return entry ? this.flush(entry) : E.BADF;
+      },
+      fd_sync: (fd) => {
+        const entry = this.fds.get(fd);
+        return entry ? this.flush(entry) : E.BADF;
+      },
+      fd_fdstat_get: (fd, ptr) => {
+        const entry = this.fds.get(fd);
+        if (!entry) return E.BADF;
+        let filetype = FT.CHARACTER_DEVICE;
+        if (entry.kind === "dir") filetype = FT.DIRECTORY;
+        else if (entry.kind === "file") filetype = FT.REGULAR_FILE;
+        const view = this.view;
+        view.setUint8(ptr, filetype);
+        view.setUint16(ptr + 2, entry.fdflags, true);
+        view.setBigUint64(ptr + 8, entry.rights, true);
+        view.setBigUint64(ptr + 16, entry.rights, true);
+        return E.SUCCESS;
+      },
+      fd_fdstat_set_flags: (fd, flags) => {
+        const entry = this.fds.get(fd);
+        if (!entry) return E.BADF;
+        entry.fdflags = flags;
+        return E.SUCCESS;
+      },
+      fd_fdstat_set_rights: (fd, base, _inheriting) => {
+        const entry = this.fds.get(fd);
+        if (!entry) return E.BADF;
+        entry.rights = base;
+        return E.SUCCESS;
+      },
+      fd_filestat_get: (fd, ptr) => {
+        const entry = this.fds.get(fd);
+        if (!entry) return E.BADF;
+        if (entry.kind === "stdin" || entry.kind === "stdout" || entry.kind === "stderr") {
+          const view = this.view;
+          new Uint8Array(this.memory.buffer, ptr, SIZEOF_FILESTAT).fill(0);
+          view.setUint8(ptr + 16, FT.CHARACTER_DEVICE);
+          view.setBigUint64(ptr + 32, BigInt(entry.data.length), true);
+          return E.SUCCESS;
+        }
+        return this.writeFilestat(ptr, entry.path, true);
+      },
+      fd_filestat_set_size: (fd, size) => {
+        const entry = this.fds.get(fd);
+        if (!entry || entry.kind !== "file") return E.BADF;
+        const length = Number(size);
+        const next = new Uint8Array(length);
+        next.set(entry.data.subarray(0, Math.min(length, entry.data.length)));
+        entry.data = next;
+        entry.dirty = true;
+        return this.flush(entry);
+      },
+      fd_filestat_set_times: (fd, atim, mtim, _flags) => {
+        const entry = this.fds.get(fd);
+        if (!entry) return E.BADF;
+        try {
+          vfs.utimes(entry.path, Number(atim) / 1e6, Number(mtim) / 1e6, cred);
+          return E.SUCCESS;
+        } catch (e) {
+          return this.errnoOf(e);
+        }
+      },
+      fd_prestat_get: (fd, ptr) => {
+        const entry = this.fds.get(fd);
+        if (!entry || entry.preopen === void 0) return E.BADF;
+        const view = this.view;
+        view.setUint8(
+          ptr,
+          0
+          /* dir */
+        );
+        view.setUint32(ptr + 4, encoder6.encode(entry.preopen).length, true);
+        return E.SUCCESS;
+      },
+      fd_prestat_dir_name: (fd, ptr, len) => {
+        const entry = this.fds.get(fd);
+        if (!entry || entry.preopen === void 0) return E.BADF;
+        const name = encoder6.encode(entry.preopen);
+        if (name.length > len) return E.NAMETOOLONG;
+        this.bytes.set(name, ptr);
+        return E.SUCCESS;
+      },
+      fd_renumber: (from, to) => {
+        const entry = this.fds.get(from);
+        if (!entry) return E.BADF;
+        const existing = this.fds.get(to);
+        if (existing) this.flush(existing);
+        this.fds.set(to, entry);
+        this.fds.delete(from);
+        return E.SUCCESS;
+      },
+      /* ── reading and writing ──────────────────────────────────────────── */
+      fd_read: (fd, iovs, iovsLen, nreadPtr) => this.readInto(fd, iovs, iovsLen, nreadPtr, null),
+      fd_pread: (fd, iovs, iovsLen, offset, nreadPtr) => this.readInto(fd, iovs, iovsLen, nreadPtr, Number(offset)),
+      fd_write: (fd, iovs, iovsLen, nwrittenPtr) => this.writeFrom(fd, iovs, iovsLen, nwrittenPtr, null),
+      fd_pwrite: (fd, iovs, iovsLen, offset, nwrittenPtr) => this.writeFrom(fd, iovs, iovsLen, nwrittenPtr, Number(offset)),
+      fd_seek: (fd, offset, whence, ptr) => {
+        const entry = this.fds.get(fd);
+        if (!entry) return E.BADF;
+        if (entry.kind === "stdout" || entry.kind === "stderr") return E.SPIPE;
+        let next = Number(offset);
+        if (whence === WHENCE_CUR) next += entry.pos;
+        else if (whence === WHENCE_END) next += entry.data.length;
+        if (next < 0) return E.INVAL;
+        entry.pos = next;
+        this.view.setBigUint64(ptr, BigInt(next), true);
+        return E.SUCCESS;
+      },
+      fd_tell: (fd, ptr) => {
+        const entry = this.fds.get(fd);
+        if (!entry) return E.BADF;
+        this.view.setBigUint64(ptr, BigInt(entry.pos), true);
+        return E.SUCCESS;
+      },
+      fd_advise: () => E.SUCCESS,
+      fd_allocate: (fd, offset, len) => {
+        const entry = this.fds.get(fd);
+        if (!entry || entry.kind !== "file") return E.BADF;
+        const end = Number(offset) + Number(len);
+        if (end > entry.data.length) {
+          const next = new Uint8Array(end);
+          next.set(entry.data);
+          entry.data = next;
+          entry.dirty = true;
+        }
+        return this.flush(entry);
+      },
+      fd_readdir: (fd, buf, bufLen, cookie, usedPtr) => {
+        const entry = this.fds.get(fd);
+        if (!entry) return E.BADF;
+        if (entry.kind !== "dir") return E.NOTDIR;
+        let names;
+        try {
+          names = [".", "..", ...vfs.readdir(entry.path, cred)];
+        } catch (e) {
+          return this.errnoOf(e);
+        }
+        const view = this.view;
+        const bytes = this.bytes;
+        let used = 0;
+        for (let i = Number(cookie); i < names.length; i++) {
+          const name = names[i];
+          const encoded = encoder6.encode(name);
+          if (used + SIZEOF_DIRENT + encoded.length > bufLen) break;
+          let type = FT.UNKNOWN;
+          try {
+            const target = name === "." ? entry.path : name === ".." ? dirname(entry.path) : join(entry.path, name);
+            type = this.filetypeOf(vfs.lstat(target).mode);
+          } catch {
+          }
+          const at = buf + used;
+          view.setBigUint64(at, BigInt(i + 1), true);
+          view.setBigUint64(at + 8, 0n, true);
+          view.setUint32(at + 16, encoded.length, true);
+          view.setUint8(at + 20, type);
+          bytes.set(encoded, at + SIZEOF_DIRENT);
+          used += SIZEOF_DIRENT + encoded.length;
+        }
+        view.setUint32(usedPtr, used, true);
+        return E.SUCCESS;
+      },
+      /* ── paths ────────────────────────────────────────────────────────── */
+      path_open: (dirfd, lookupflags, pathPtr, pathLen, oflags, rightsBase, _rightsInheriting, fdflags, fdPtr) => {
+        const resolved = this.resolveAt(dirfd, this.readString(pathPtr, pathLen));
+        if (typeof resolved === "number") return resolved;
+        let path = resolved.path;
+        const wantsWrite = (rightsBase & RIGHT_FD_WRITE) !== 0n || (oflags & (O_CREAT | O_TRUNC)) !== 0;
+        const follow = (lookupflags & LOOKUP_SYMLINK_FOLLOW) !== 0;
+        try {
+          if (follow && vfs.lexists(path)) path = vfs.realpath(path, cred);
+        } catch {
+        }
+        const exists = vfs.lexists(path);
+        if (exists && (oflags & O_EXCL) !== 0 && (oflags & O_CREAT) !== 0) return E.EXIST;
+        if (!exists && (oflags & O_CREAT) === 0) return E.NOENT;
+        try {
+          if (!exists) {
+            if ((oflags & O_DIRECTORY) !== 0) {
+              vfs.mkdir(path, { cred, mode: 493 });
+            } else {
+              vfs.writeFile(path, new Uint8Array(0), { cred, mode: 420 });
+            }
+          }
+          const st = vfs.lstat(path);
+          const isDir = (st.mode & 61440) === S_IFDIR;
+          if ((oflags & O_DIRECTORY) !== 0 && !isDir) return E.NOTDIR;
+          if (isDir && wantsWrite) return E.ISDIR;
+          let data = new Uint8Array(0);
+          if (!isDir) {
+            data = (oflags & O_TRUNC) !== 0 ? new Uint8Array(0) : vfs.readFile(path, cred);
+            if ((oflags & O_TRUNC) !== 0) vfs.writeFile(path, data, { cred });
+          }
+          const fd = this.allocateFd();
+          this.fds.set(fd, {
+            kind: isDir ? "dir" : "file",
+            path,
+            pos: (fdflags & FD_APPEND) !== 0 ? data.length : 0,
+            data,
+            dirty: false,
+            fdflags,
+            /* The requested rights are recorded but not enforced: the
+             * container's own uid/gid permission bits already gated the open,
+             * and layering WASI's capability set on top of them only invents
+             * ENOTCAPABLE failures for modules whose toolchain requests a
+             * narrower set than it then uses. A module may still drop its own
+             * rights through `fd_fdstat_set_rights`, and that is honoured. */
+            rights: RIGHTS_ALL
+          });
+          this.view.setUint32(fdPtr, fd, true);
+          return E.SUCCESS;
+        } catch (e) {
+          return this.errnoOf(e);
+        }
+      },
+      path_filestat_get: (dirfd, flags, pathPtr, pathLen, statPtr) => {
+        const resolved = this.resolveAt(dirfd, this.readString(pathPtr, pathLen));
+        if (typeof resolved === "number") return resolved;
+        return this.writeFilestat(statPtr, resolved.path, (flags & LOOKUP_SYMLINK_FOLLOW) !== 0);
+      },
+      path_filestat_set_times: (dirfd, _flags, pathPtr, pathLen, atim, mtim, _fstflags) => {
+        const resolved = this.resolveAt(dirfd, this.readString(pathPtr, pathLen));
+        if (typeof resolved === "number") return resolved;
+        try {
+          vfs.utimes(resolved.path, Number(atim) / 1e6, Number(mtim) / 1e6, cred);
+          return E.SUCCESS;
+        } catch (e) {
+          return this.errnoOf(e);
+        }
+      },
+      path_create_directory: (dirfd, pathPtr, pathLen) => {
+        const resolved = this.resolveAt(dirfd, this.readString(pathPtr, pathLen));
+        if (typeof resolved === "number") return resolved;
+        try {
+          vfs.mkdir(resolved.path, { cred, mode: 493 });
+          return E.SUCCESS;
+        } catch (e) {
+          return this.errnoOf(e);
+        }
+      },
+      path_remove_directory: (dirfd, pathPtr, pathLen) => {
+        const resolved = this.resolveAt(dirfd, this.readString(pathPtr, pathLen));
+        if (typeof resolved === "number") return resolved;
+        try {
+          vfs.rmdir(resolved.path, cred);
+          return E.SUCCESS;
+        } catch (e) {
+          return this.errnoOf(e);
+        }
+      },
+      path_unlink_file: (dirfd, pathPtr, pathLen) => {
+        const resolved = this.resolveAt(dirfd, this.readString(pathPtr, pathLen));
+        if (typeof resolved === "number") return resolved;
+        try {
+          vfs.unlink(resolved.path, cred);
+          return E.SUCCESS;
+        } catch (e) {
+          return this.errnoOf(e);
+        }
+      },
+      path_rename: (oldFd, oldPtr, oldLen, newFd, newPtr, newLen) => {
+        const from = this.resolveAt(oldFd, this.readString(oldPtr, oldLen));
+        if (typeof from === "number") return from;
+        const to = this.resolveAt(newFd, this.readString(newPtr, newLen));
+        if (typeof to === "number") return to;
+        try {
+          vfs.rename(from.path, to.path, cred);
+          return E.SUCCESS;
+        } catch (e) {
+          return this.errnoOf(e);
+        }
+      },
+      path_symlink: (targetPtr, targetLen, dirfd, pathPtr, pathLen) => {
+        const resolved = this.resolveAt(dirfd, this.readString(pathPtr, pathLen));
+        if (typeof resolved === "number") return resolved;
+        try {
+          vfs.symlink(this.readString(targetPtr, targetLen), resolved.path, cred);
+          return E.SUCCESS;
+        } catch (e) {
+          return this.errnoOf(e);
+        }
+      },
+      path_readlink: (dirfd, pathPtr, pathLen, buf, bufLen, usedPtr) => {
+        const resolved = this.resolveAt(dirfd, this.readString(pathPtr, pathLen));
+        if (typeof resolved === "number") return resolved;
+        try {
+          const target = encoder6.encode(vfs.readlink(resolved.path, cred));
+          const size = Math.min(target.length, bufLen);
+          this.bytes.set(target.subarray(0, size), buf);
+          this.view.setUint32(usedPtr, size, true);
+          return E.SUCCESS;
+        } catch (e) {
+          return this.errnoOf(e);
+        }
+      },
+      path_link: (oldFd, _flags, oldPtr, oldLen, newFd, newPtr, newLen) => {
+        const from = this.resolveAt(oldFd, this.readString(oldPtr, oldLen));
+        if (typeof from === "number") return from;
+        const to = this.resolveAt(newFd, this.readString(newPtr, newLen));
+        if (typeof to === "number") return to;
+        try {
+          vfs.link(from.path, to.path, cred);
+          return E.SUCCESS;
+        } catch (e) {
+          return this.errnoOf(e);
+        }
+      },
+      /* ── polling ──────────────────────────────────────────────────────── */
+      /**
+       * Clock subscriptions only, and they resolve immediately.
+       *
+       * Everything here is synchronous, so a genuine wait would deadlock the
+       * whole container rather than yield to anything. Reporting the timer as
+       * already elapsed lets `sleep` and timeout loops complete instead of
+       * hanging; subscriptions on a descriptor report readiness, since stdin is
+       * already buffered and stdout never blocks.
+       */
+      poll_oneoff: (inPtr, outPtr, nsubs, neventsPtr) => {
+        const view = this.view;
+        for (let i = 0; i < nsubs; i++) {
+          const sub = inPtr + i * 48;
+          const userdata = view.getBigUint64(sub, true);
+          const type = view.getUint8(sub + 8);
+          const event = outPtr + i * 32;
+          view.setBigUint64(event, userdata, true);
+          view.setUint16(event + 8, E.SUCCESS, true);
+          view.setUint8(event + 10, type);
+          view.setBigUint64(event + 16, 0n, true);
+          view.setUint16(event + 24, 0, true);
+        }
+        view.setUint32(neventsPtr, nsubs, true);
+        return E.SUCCESS;
+      },
+      /* ── sockets ──────────────────────────────────────────────────────── */
+      sock_accept: () => E.NOTSUP,
+      sock_recv: () => E.NOTSUP,
+      sock_send: () => E.NOTSUP,
+      sock_shutdown: () => E.NOTSUP
+    };
+  }
+  /* ── shared read/write paths ────────────────────────────────────────────── */
+  readInto(fd, iovs, iovsLen, nreadPtr, offset) {
+    const entry = this.fds.get(fd);
+    if (!entry) return E.BADF;
+    if (entry.kind === "dir") return E.ISDIR;
+    if (entry.kind === "stdout" || entry.kind === "stderr") return E.BADF;
+    if ((entry.rights & RIGHT_FD_READ) === 0n) return E.NOTCAPABLE;
+    let position = offset ?? entry.pos;
+    let read = 0;
+    const bytes = this.bytes;
+    for (const iov of this.iovecs(iovs, iovsLen)) {
+      if (position >= entry.data.length) break;
+      const chunk = entry.data.subarray(position, position + iov.len);
+      bytes.set(chunk, iov.base);
+      position += chunk.length;
+      read += chunk.length;
+      if (chunk.length < iov.len) break;
+    }
+    if (offset === null) entry.pos = position;
+    this.view.setUint32(nreadPtr, read, true);
+    return E.SUCCESS;
+  }
+  writeFrom(fd, iovs, iovsLen, nwrittenPtr, offset) {
+    const entry = this.fds.get(fd);
+    if (!entry) return E.BADF;
+    if (entry.kind === "dir") return E.ISDIR;
+    if (entry.kind === "stdin") return E.BADF;
+    if ((entry.rights & RIGHT_FD_WRITE) === 0n) return E.NOTCAPABLE;
+    const chunks = [];
+    let total = 0;
+    const bytes = this.bytes;
+    for (const iov of this.iovecs(iovs, iovsLen)) {
+      chunks.push(bytes.slice(iov.base, iov.base + iov.len));
+      total += iov.len;
+    }
+    if (entry.kind === "stdout" || entry.kind === "stderr") {
+      const sink = entry.kind === "stdout" ? this.opts.stdout : this.opts.stderr;
+      for (const chunk of chunks) sink(chunk);
+      this.view.setUint32(nwrittenPtr, total, true);
+      return E.SUCCESS;
+    }
+    let position = offset ?? ((entry.fdflags & FD_APPEND) !== 0 ? entry.data.length : entry.pos);
+    const end = Math.max(entry.data.length, position + total);
+    if (end > entry.data.length) {
+      const grown = new Uint8Array(end);
+      grown.set(entry.data);
+      entry.data = grown;
+    }
+    for (const chunk of chunks) {
+      entry.data.set(chunk, position);
+      position += chunk.length;
+    }
+    if (offset === null) entry.pos = position;
+    entry.dirty = true;
+    const status = this.flush(entry);
+    if (status !== E.SUCCESS) return status;
+    this.view.setUint32(nwrittenPtr, total, true);
+    return E.SUCCESS;
+  }
+  allocateFd() {
+    while (this.fds.has(this.nextFd)) this.nextFd++;
+    return this.nextFd++;
+  }
+  envPairs() {
+    return Object.entries(this.opts.env).filter(([, value]) => value !== void 0).map(([key, value]) => `${key}=${value}`);
+  }
+  /** Flush and drop every open descriptor. Safe to call twice. */
+  close() {
+    for (const [fd, entry] of this.fds) {
+      if (entry.kind === "file") this.flush(entry);
+      if (fd > 2) this.fds.delete(fd);
+    }
+  }
+};
+
+// src/runtime/wasm.ts
+init_path();
+var WASM_MAGIC = [0, 97, 115, 109];
+function isWasmBinary(head2) {
+  return head2.length >= 4 && WASM_MAGIC.every((byte, i) => head2[i] === byte);
+}
+function analyse(module) {
+  const imports = WebAssembly.Module.imports(module);
+  const exports = WebAssembly.Module.exports(module).map((e) => e.name);
+  const modules = [...new Set(imports.map((i) => i.module))];
+  const importsMemory = imports.some((i) => i.kind === "memory");
+  const wantsThreads = imports.some(
+    (i) => i.kind === "memory" && i.type?.shared === true
+  );
+  let flavour = "core";
+  if (modules.some((m) => m === "wasi_snapshot_preview1" || m === "wasi_unstable")) flavour = "wasi";
+  else if (modules.some((m) => m.startsWith("wasi:"))) flavour = "wasi-component";
+  else if (modules.includes("gojs") || modules.includes("go")) flavour = "go-js";
+  else if (modules.some((m) => m.startsWith("./") || m.endsWith("_bg.js"))) flavour = "wasm-bindgen";
+  else if (modules.includes("env") || modules.includes("wasi_snapshot_preview1")) flavour = "emscripten";
+  return { flavour, modules, importsMemory, wantsThreads, exports };
+}
+var compiled2 = /* @__PURE__ */ new Map();
+var MAX_CACHED = 16;
+async function compile(ctx, path) {
+  const st = ctx.vfs.stat(path, { cred: ctx.cred });
+  const hit = compiled2.get(path);
+  if (hit && hit.mtimeMs === st.mtimeMs && hit.size === st.size) return hit.module;
+  const bytes = ctx.vfs.readFile(path, ctx.cred);
+  const buffer = bytes.buffer.slice(bytes.byteOffset, bytes.byteOffset + bytes.byteLength);
+  const module = await WebAssembly.compile(buffer);
+  if (compiled2.size >= MAX_CACHED) {
+    const oldest = compiled2.keys().next().value;
+    if (oldest !== void 0) compiled2.delete(oldest);
+  }
+  compiled2.set(path, { mtimeMs: st.mtimeMs, size: st.size, module });
+  return module;
+}
+async function runWasi(ctx, path, argv0) {
+  let module;
+  try {
+    module = await compile(ctx, path);
+  } catch (e) {
+    ctx.warn(`${path}: not a valid WebAssembly module (${e instanceof Error ? e.message : String(e)})`);
+    return 126;
+  }
+  const info = analyse(module);
+  if (info.flavour !== "wasi") {
+    for (const line of explainFlavour(info, path, findLoader(ctx, path))) ctx.stderr.write(line + "\n");
+    return 126;
+  }
+  if (info.wantsThreads) {
+    ctx.warn("this module was built with threads (shared memory), which this container cannot provide");
+    return 126;
+  }
+  let stdin = new Uint8Array(0);
+  if (!ctx.stdin.isTTY && !ctx.stdin.interactive) {
+    stdin = await ctx.stdin.readAll();
+  }
+  const wasi = new WasiPreview1({
+    vfs: ctx.vfs,
+    cred: ctx.cred,
+    args: [argv0 ?? basename(path), ...ctx.args],
+    env: ctx.env,
+    cwd: ctx.cwd,
+    stdin,
+    stdout: (bytes) => ctx.write(bytes),
+    stderr: (bytes) => ctx.stderr.write(bytes),
+    now: ctx.kernel.now
+  });
+  let instance;
+  try {
+    instance = await WebAssembly.instantiate(module, wasi.imports);
+  } catch (e) {
+    ctx.warn(`cannot start: ${e instanceof Error ? e.message : String(e)}`);
+    return 126;
+  }
+  try {
+    wasi.bind(instance);
+  } catch (e) {
+    ctx.warn(e instanceof Error ? e.message : String(e));
+    return 126;
+  }
+  const start = instance.exports._start ?? instance.exports._initialize;
+  if (typeof start !== "function") {
+    ctx.warn("module exports neither _start nor _initialize; it is a library, not a command");
+    return 126;
+  }
+  try {
+    start();
+    return wasi.exited ?? 0;
+  } catch (e) {
+    if (e instanceof WasiExit) return e.code;
+    ctx.warn(e instanceof Error ? e.message : String(e));
+    return 128 + 6;
+  } finally {
+    wasi.close();
+  }
+}
+function findLoader(ctx, path) {
+  const stem = join(dirname(path), basename(path, ".wasm")).replace(/_bg$/, "");
+  for (const candidate of [`${stem}.js`, `${stem}.mjs`, `${stem}.cjs`]) {
+    if (ctx.vfs.lexists(candidate)) return candidate;
+  }
+  return null;
+}
+function explainFlavour(info, path, loader) {
+  const name = basename(path);
+  if (loader) {
+    return [
+      `${name}: this module is loaded by a JavaScript harness, not executed directly.`,
+      "It imports host functions that only that harness provides. Run it instead:",
+      `  node ${loader}`
+    ];
+  }
+  switch (info.flavour) {
+    case "wasi-component":
+      return [
+        `${name}: this is a WebAssembly component (WASI preview 2), not a core module.`,
+        "Components cannot be instantiated directly. Transpile it to a core module first:",
+        "  npx @bytecodealliance/jco transpile " + name + " -o out"
+      ];
+    case "emscripten":
+      return [
+        `${name}: this is an Emscripten build, which is only half a program.`,
+        "It needs the JavaScript loader generated alongside it. Run that instead:",
+        `  node ${basename(path, ".wasm")}.js`
+      ];
+    case "wasm-bindgen":
+      return [
+        `${name}: this is a wasm-bindgen build; its imports come from a JS glue module.`,
+        "Load it from Node rather than executing it:",
+        `  node -e "import('./${basename(path, "_bg.wasm")}.js')"`
+      ];
+    case "go-js":
+      return [
+        `${name}: this was built with GOOS=js, which needs Go's wasm_exec.js harness.`,
+        "Rebuild it for WASI instead, and it will run here directly:",
+        "  GOOS=wasip1 GOARCH=wasm go build -o " + name
+      ];
+    default:
+      return [
+        `${name}: a core WebAssembly module with no WASI imports.`,
+        "There is no entry point to call and no way to reach stdin, stdout or the",
+        "filesystem. Build it for wasm32-wasi to run it as a command."
+      ];
+  }
+}
+var wasmFormat = {
+  name: "wasm",
+  priority: 10,
+  matches: (head2) => isWasmBinary(head2),
+  describe: () => "WebAssembly (wasm) binary module",
+  run: (ctx, path) => runWasi(ctx, path, ctx.name)
+};
+var wasm = defineCommand({
+  name: "wasm",
+  path: "/usr/bin/wasm",
+  summary: "run and inspect WebAssembly modules",
+  usage: "wasm run <module.wasm> [args...] | wasm info <module.wasm>",
+  manual: `Runs a WASI command module against the container's filesystem, or
+reports what a module was built for.
+
+Any file starting with the WebAssembly magic bytes is also executable
+directly, so 'chmod +x tool.wasm && ./tool.wasm' does the same thing as
+'wasm run tool.wasm'.`,
+  async run(ctx) {
+    const [subcommand, target, ...rest] = ctx.args;
+    if (subcommand === void 0 || subcommand === "--help" || subcommand === "-h") {
+      ctx.line("Usage: wasm run <module.wasm> [args...]");
+      ctx.line("       wasm info <module.wasm>");
+      return subcommand === void 0 ? 2 : 0;
+    }
+    if (target === void 0) return ctx.fail(`${subcommand}: a module path is required`, 2);
+    const path = ctx.path(target);
+    if (!ctx.vfs.lexists(path)) return ctx.fail(`${target}: No such file or directory`, 1);
+    if (subcommand === "run") {
+      return await runWasi({ ...ctx, args: rest, argv: [basename(path), ...rest] }, path, basename(path));
+    }
+    if (subcommand === "info") {
+      let module;
+      try {
+        module = await compile(ctx, path);
+      } catch (e) {
+        return ctx.fail(`${target}: ${e instanceof Error ? e.message : String(e)}`, 1);
+      }
+      const info = analyse(module);
+      const runnable = info.flavour === "wasi" && !info.wantsThreads;
+      ctx.line(`file:      ${path}`);
+      ctx.line(`flavour:   ${info.flavour}`);
+      ctx.line(`imports:   ${info.modules.join(", ") || "(none)"}`);
+      ctx.line(`threads:   ${info.wantsThreads ? "yes (unsupported)" : "no"}`);
+      ctx.line(`entry:     ${info.exports.includes("_start") ? "_start" : info.exports.includes("_initialize") ? "_initialize (reactor)" : "none"}`);
+      ctx.line(`runnable:  ${runnable ? "yes" : "no"}`);
+      if (!runnable) {
+        ctx.line("");
+        for (const line of explainFlavour(info, path, findLoader(ctx, path))) ctx.line(line);
+      }
+      return 0;
+    }
+    return ctx.fail(`unknown subcommand: ${subcommand}`, 2);
+  }
+});
+function wasmCommands() {
+  return [wasm];
+}
+
+// src/runtime/native-format.ts
+init_path();
+var ELF_MACHINES = {
+  2: "SPARC",
+  3: "x86",
+  8: "MIPS",
+  20: "PowerPC",
+  21: "PowerPC 64-bit",
+  22: "S/390",
+  40: "ARM",
+  42: "SuperH",
+  50: "IA-64",
+  62: "x86-64",
+  183: "AArch64",
+  243: "RISC-V"
+};
+var ELF_TYPES = {
+  1: "relocatable",
+  2: "executable",
+  3: "shared object",
+  4: "core dump"
+};
+function describeElf(head2) {
+  const bits = head2[4] === 2 ? "64-bit" : "32-bit";
+  const endian = head2[5] === 2 ? "MSB" : "LSB";
+  if (head2.length < 20) return `ELF ${bits} ${endian} object`;
+  const view = new DataView(head2.buffer, head2.byteOffset, head2.byteLength);
+  const little = head2[5] !== 2;
+  const type = ELF_TYPES[view.getUint16(16, little)] ?? "object";
+  const machine = view.getUint16(18, little);
+  return `ELF ${bits} ${endian} ${type}, ${ELF_MACHINES[machine] ?? `machine 0x${machine.toString(16)}`}`;
+}
+var SUGGEST_WASM = [
+  "Nothing in this container can execute machine code \u2014 there is no CPU here to",
+  "run it on, only JavaScript and WebAssembly.",
+  "",
+  "If the tool has a WebAssembly build, it will run here as-is: drop the .wasm",
+  "file in /usr/local/bin, chmod +x it, and call it by name."
+];
+var elfFormat = {
+  name: "elf",
+  priority: 20,
+  matches: (head2) => head2.length >= 4 && head2[0] === 127 && head2[1] === 69 && head2[2] === 76 && head2[3] === 70,
+  describe: describeElf,
+  explain: (head2, path) => [`${basename(path)}: ${describeElf(head2)}.`, ...SUGGEST_WASM]
+};
+var machoFormat = {
+  name: "mach-o",
+  priority: 20,
+  matches: (head2) => {
+    if (head2.length < 4) return false;
+    const magic = new DataView(head2.buffer, head2.byteOffset, head2.byteLength).getUint32(0, false);
+    return magic === 4277009102 || magic === 4277009103 || magic === 3472551422 || magic === 3489328638 || magic === 3405691582;
+  },
+  describe: () => "Mach-O executable (macOS)",
+  explain: (_head, path) => [`${basename(path)}: Mach-O executable (macOS native binary).`, ...SUGGEST_WASM]
+};
+var peFormat = {
+  name: "pe",
+  priority: 25,
+  // `MZ` alone is weak, so require the DOS stub text that every real PE carries.
+  matches: (head2) => head2.length >= 64 && head2[0] === 77 && head2[1] === 90 && new TextDecoder().decode(head2.subarray(0, 128)).includes("This program cannot be run in DOS mode"),
+  describe: () => "PE32+ executable (Windows)",
+  explain: (_head, path) => [`${basename(path)}: PE executable (Windows native binary).`, ...SUGGEST_WASM]
+};
+function nativeFormats() {
+  return [elfFormat, machoFormat, peFormat];
+}
 var DECLARES_EXPORTS = /(?:^|[\s;{)])(?:var|let|const|function|class)\s+exports\b/;
 var NAME = "exports";
 function renameShadowedExports(source) {
@@ -22849,6 +23913,143 @@ var NOTHING = [];
 var PROPERTY = ["property", "key"];
 var LABEL = ["label"];
 
+// src/pkg/install.ts
+init_path();
+var GLOBAL_PREFIX = "/usr/local";
+var GLOBAL_MODULES = `${GLOBAL_PREFIX}/lib/node_modules`;
+var GLOBAL_BIN = `${GLOBAL_PREFIX}/bin`;
+function readManifestAt(ctx, dir3) {
+  try {
+    return JSON.parse(ctx.vfs.readText(join(dir3, "package.json"), ctx.cred));
+  } catch {
+    return null;
+  }
+}
+function binEntries(manifest, packageName) {
+  if (typeof manifest.bin === "string") return { [basename(packageName)]: manifest.bin };
+  if (manifest.bin && typeof manifest.bin === "object") return { ...manifest.bin };
+  return {};
+}
+function linkPackageBinaries(ctx, packageDir, packageName, binDir) {
+  const manifest = readManifestAt(ctx, packageDir);
+  if (!manifest) return [];
+  const linked = [];
+  if (!ctx.vfs.lexists(binDir)) ctx.vfs.mkdir(binDir, { recursive: true, mode: 493 });
+  for (const [name, relative2] of Object.entries(binEntries(manifest, packageName))) {
+    const target = resolve(packageDir, relative2);
+    if (!ctx.vfs.lexists(target)) continue;
+    let script;
+    try {
+      script = isJavaScriptEntry(ctx, target) ? `#!/bin/sh
+exec node ${quote(target)} "$@"
+` : `#!/bin/sh
+exec ${quote(target)} "$@"
+`;
+    } catch {
+      continue;
+    }
+    const link = join(binDir, name);
+    ctx.vfs.writeFile(link, script, { privileged: true, mode: 493 });
+    ctx.vfs.chmod(link, 493);
+    try {
+      ctx.vfs.chmod(target, 493, ctx.cred);
+    } catch {
+    }
+    linked.push(name);
+  }
+  return linked;
+}
+function quote(value) {
+  return /^[A-Za-z0-9_@%+=:,./-]+$/.test(value) ? value : `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function isJavaScriptEntry(ctx, target) {
+  const head2 = ctx.vfs.readFile(ctx.vfs.realpath(target, ctx.cred), ctx.cred).subarray(0, 256);
+  if (isWasmBinary(head2)) return false;
+  const text = new TextDecoder().decode(head2);
+  if (text.startsWith("#!")) {
+    return false;
+  }
+  if (head2.includes(0)) return false;
+  const ext = extname(target);
+  if (JS_EXTENSIONS.has(ext) && ext !== "") return true;
+  return !/^\s*(echo|set|export|if|exec)\s/.test(text);
+}
+var LIFECYCLE = ["preinstall", "install", "postinstall"];
+async function runLifecycleScripts(ctx, packageDir, packageName, opts = {}) {
+  const manifest = readManifestAt(ctx, packageDir);
+  const scripts = manifest?.scripts;
+  if (!scripts) return;
+  for (const hook of LIFECYCLE) {
+    const script = scripts[hook];
+    if (!script) continue;
+    if (!opts.quiet) ctx.stderr.write(`
+> ${packageName} ${hook}
+> ${script}
+`);
+    const binDir = join(packageDir, "node_modules", ".bin");
+    const result = await ctx.kernel.run(["/bin/sh", "-c", script], {
+      cwd: packageDir,
+      cred: ctx.cred,
+      ppid: ctx.proc.pid,
+      env: {
+        ...ctx.env,
+        PATH: `${binDir}:${GLOBAL_BIN}:${ctx.env.PATH ?? ""}`,
+        npm_lifecycle_event: hook,
+        npm_lifecycle_script: script,
+        npm_package_name: manifest.name ?? packageName,
+        npm_package_version: manifest.version ?? "",
+        INIT_CWD: ctx.cwd
+      },
+      // Hooks that wait on something that will never arrive are common enough
+      // to need a bound; without one a single package hangs the install.
+      timeoutMs: opts.timeoutMs ?? 6e4
+    });
+    if (result.exitCode !== 0) {
+      ctx.stderr.write(`npm warn ${packageName}: ${hook} script failed (exit ${result.exitCode})
+`);
+      const detail = (result.stderr || result.stdout).trim().split("\n").slice(-3);
+      for (const line of detail) if (line) ctx.stderr.write(`npm warn   ${line}
+`);
+      return;
+    }
+    if (!opts.quiet && result.stdout) ctx.stderr.write(result.stdout);
+  }
+}
+var JS_EXTENSIONS = /* @__PURE__ */ new Set([".js", ".mjs", ".cjs", ".ts", ""]);
+function inspectPackage(ctx, packageDir, packageName) {
+  const manifest = readManifestAt(ctx, packageDir);
+  if (!manifest) return { verdict: "empty", lines: [`${packageName}: installed, but has no package.json`] };
+  const bins = binEntries(manifest, packageName);
+  if (Object.keys(bins).length === 0) {
+    return { verdict: "ok", lines: [] };
+  }
+  const nativeBins = Object.entries(bins).filter(([, relative2]) => !JS_EXTENSIONS.has(extname(relative2)));
+  const platformDeps = Object.keys(manifest.optionalDependencies ?? {}).filter(
+    (dep) => /-(linux|darwin|win32|windows|freebsd)(-|$)|-(x64|arm64|ia32)(-|$)/.test(dep)
+  );
+  if (nativeBins.length === 0 && platformDeps.length === 0) return { verdict: "ok", lines: [] };
+  const lines = [];
+  const label = manifest.name ?? packageName;
+  if (nativeBins.length > 0) {
+    const [name, relative2] = nativeBins[0];
+    lines.push(`${label}: '${name}' points at ${relative2}, which is a compiled executable, not JavaScript.`);
+  } else {
+    lines.push(`${label}: ships its executable as a platform-specific package, not as JavaScript.`);
+  }
+  if (platformDeps.length > 0) {
+    const shown = platformDeps.slice(0, 3).join(", ");
+    lines.push(
+      `Its real binary comes from ${platformDeps.length} platform packages (${shown}${platformDeps.length > 3 ? ", \u2026" : ""}),`
+    );
+    lines.push("each of which is native machine code for one OS and CPU.");
+  }
+  lines.push("");
+  lines.push("This container has no CPU to run machine code on \u2014 only JavaScript and");
+  lines.push("WebAssembly. The package is installed and its files are on disk, but the");
+  lines.push("command it provides cannot start.");
+  return { verdict: "native", lines };
+}
+
 // src/pkg/index.ts
 init_path();
 var NPM_VERSION = "10.9.0";
@@ -22873,6 +24074,9 @@ function findProjectRoot(ctx) {
 function writeManifest(ctx, path, manifest) {
   ctx.vfs.writeFile(path, JSON.stringify(manifest, null, 2) + "\n", { cred: ctx.cred, mode: 420 });
 }
+function isGlobal(args) {
+  return args.some((a) => a === "-g" || a === "--global" || a === "--location=global");
+}
 function splitPackageSpec(spec) {
   const at = spec.lastIndexOf("@");
   if (at <= 0) return { name: spec };
@@ -22905,19 +24109,93 @@ async function installPackages(ctx, specs, opts) {
         note(`added ${name}${version ? `@${version}` : ""}`);
         await installer.install(name, version, {
           onProgress,
-          persist: opts.save !== false,
+          // A global install belongs to the prefix, not to whatever project
+          // happens to be in the working directory, so nothing is recorded in
+          // a manifest — which is also what npm does.
+          persist: opts.global ? false : opts.save !== false,
           persistDev: opts.dev === true
         });
       }
     }
     normalizeBinDirectories(ctx, opts.cwd);
     normalizeEsmExports(ctx, opts.cwd);
+    if (opts.global) {
+      return await linkGlobalPackages(ctx, opts.cwd, specs, opts.quiet === true, opts.ignoreScripts !== true);
+    }
+    if (opts.ignoreScripts !== true) await runProjectLifecycleScripts(ctx, opts.cwd, specs, opts.quiet === true);
     return 0;
   } catch (e) {
     ctx.warn(`npm error ${e instanceof Error ? e.message : String(e)}`);
     return 1;
   }
 }
+async function runProjectLifecycleScripts(ctx, root, specs, quiet) {
+  for (const spec of specs) {
+    const { name } = splitPackageSpec(spec);
+    const dir3 = join(root, "node_modules", name);
+    if (ctx.vfs.lexists(dir3)) await runLifecycleScripts(ctx, dir3, name, { quiet });
+  }
+  normalizeBinDirectories(ctx, root);
+}
+async function linkGlobalPackages(ctx, stagingRoot, specs, quiet, runScripts) {
+  const staged = join(stagingRoot, "node_modules");
+  if (!ctx.vfs.lexists(staged)) return 0;
+  if (!ctx.vfs.lexists(GLOBAL_MODULES)) ctx.vfs.mkdir(GLOBAL_MODULES, { recursive: true, mode: 493 });
+  for (const entry of ctx.vfs.readdir(staged, ctx.cred)) {
+    if (entry === ".bin") continue;
+    const from = join(staged, entry);
+    const to = join(GLOBAL_MODULES, entry);
+    try {
+      if (entry.startsWith("@")) {
+        if (!ctx.vfs.lexists(to)) ctx.vfs.mkdir(to, { recursive: true, mode: 493 });
+        for (const scoped of ctx.vfs.readdir(from, ctx.cred)) {
+          const target = join(to, scoped);
+          if (ctx.vfs.lexists(target)) ctx.vfs.rmrf(target, ctx.cred);
+          ctx.vfs.copyTree(join(from, scoped), target, ctx.cred);
+        }
+      } else {
+        if (ctx.vfs.lexists(to)) ctx.vfs.rmrf(to, ctx.cred);
+        ctx.vfs.copyTree(from, to, ctx.cred);
+      }
+    } catch (e) {
+      ctx.warn(`npm warn could not install ${entry} globally: ${e instanceof Error ? e.message : String(e)}`);
+    }
+  }
+  ctx.vfs.rmrf(staged, ctx.cred);
+  for (const leftover of ["package.json", "package-lock.json"]) {
+    const path = join(stagingRoot, leftover);
+    if (stagingRoot === "/" && ctx.vfs.lexists(path)) {
+      try {
+        ctx.vfs.unlink(path, ctx.cred);
+      } catch {
+      }
+    }
+  }
+  let status = 0;
+  for (const spec of specs) {
+    const { name } = splitPackageSpec(spec);
+    const dir3 = join(GLOBAL_MODULES, name);
+    if (!ctx.vfs.lexists(dir3)) continue;
+    if (runScripts) await runLifecycleScripts(ctx, dir3, name, { quiet });
+    const linked = linkPackageBinaries(ctx, dir3, name, GLOBAL_BIN);
+    const report = inspectPackage(ctx, dir3, name);
+    if (report.verdict !== "ok") {
+      ctx.stderr.write("\n");
+      for (const line of report.lines) ctx.stderr.write(`npm warn ${line}
+`);
+      status = report.verdict === "native" ? 1 : status;
+      continue;
+    }
+    if (!quiet) {
+      if (linked.length > 0) {
+        for (const bin of linked) ctx.line(`${join(GLOBAL_BIN, bin)} -> ${join(dir3, "")}`);
+      } else {
+        ctx.line(`${name} installed to ${GLOBAL_MODULES} (it declares no commands)`);
+      }
+    }
+  }
+  return status;
+}
 var npm = defineCommand({
   name: "npm",
   path: "/usr/bin/npm",
@@ -22968,17 +24246,56 @@ var npm = defineCommand({
           { long: "production" },
           { long: "omit", arg: true },
           { long: "legacy-peer-deps" },
+          { long: "ignore-scripts" },
           { short: "f", long: "force" }
         ], { allowUnknown: true });
+        if (args.has("global")) {
+          if (args.positional.length === 0) {
+            ctx.warn("npm error a package name is required for a global install");
+            return 1;
+          }
+          const staging = `/var/tmp/.npm-global-${ctx.proc.pid}`;
+          ctx.vfs.mkdir(staging, { recursive: true, mode: 493 });
+          try {
+            return await installPackages(ctx, args.positional, {
+              cwd: staging,
+              save: false,
+              global: true,
+              ignoreScripts: args.has("ignore-scripts")
+            });
+          } finally {
+            try {
+              ctx.vfs.rmrf(staging, ctx.cred);
+            } catch {
+            }
+          }
+        }
         return await installPackages(ctx, args.positional, {
           dev: args.has("save-dev"),
           save: !args.has("no-save"),
-          cwd: root
+          cwd: root,
+          ignoreScripts: args.has("ignore-scripts")
         });
       }
       case "uninstall":
       case "remove":
       case "rm": {
+        if (isGlobal(rest)) {
+          for (const name of rest.filter((a) => !a.startsWith("-"))) {
+            const dir3 = join(GLOBAL_MODULES, name);
+            if (!ctx.vfs.lexists(dir3)) {
+              ctx.warn(`npm warn ${name} is not installed globally`);
+              continue;
+            }
+            for (const bin of Object.keys(binEntries(readManifestAt(ctx, dir3) ?? {}, name))) {
+              const link = join(GLOBAL_BIN, bin);
+              if (ctx.vfs.lexists(link)) ctx.vfs.rmrf(link, ctx.cred);
+            }
+            ctx.vfs.rmrf(dir3, ctx.cred);
+            ctx.line(`removed ${name}`);
+          }
+          return 0;
+        }
         const found = readManifest(ctx, root);
         for (const name of rest.filter((a) => !a.startsWith("-"))) {
           const target = join(root, "node_modules", name);
@@ -22994,6 +24311,16 @@ var npm = defineCommand({
       }
       case "ls":
       case "list": {
+        if (isGlobal(rest)) {
+          ctx.line(`${GLOBAL_PREFIX}/lib`);
+          if (!ctx.vfs.lexists(GLOBAL_MODULES)) return 0;
+          const names2 = ctx.vfs.readdir(GLOBAL_MODULES, ctx.cred).filter((n) => !n.startsWith("."));
+          names2.forEach((name, idx) => {
+            const manifest = readManifestAt(ctx, join(GLOBAL_MODULES, name));
+            ctx.line(`${idx === names2.length - 1 ? "\u2514\u2500\u2500" : "\u251C\u2500\u2500"} ${name}@${manifest?.version ?? ""}`);
+          });
+          return 0;
+        }
         const found = readManifest(ctx, root);
         ctx.line(`${found?.manifest.name ?? basename(root)}@${found?.manifest.version ?? "1.0.0"} ${root}`);
         const modules = join(root, "node_modules");
@@ -23041,13 +24368,49 @@ var npm = defineCommand({
         ctx.line("");
         return await runScript(ctx, root, script, scriptArgs, found.manifest);
       }
+      /* Re-run install hooks and rebuild the `$PATH` shims for packages that
+       * are already on disk. Useful here for the same reason it is useful on a
+       * real system — a package whose entry point was generated, replaced or
+       * repaired after installation needs its links redone — and it works
+       * offline, since nothing is fetched. */
+      case "rebuild": {
+        const global = isGlobal(rest);
+        const modulesDir = global ? GLOBAL_MODULES : join(root, "node_modules");
+        const binDir = global ? GLOBAL_BIN : join(root, "node_modules", ".bin");
+        if (!ctx.vfs.lexists(modulesDir)) return ctx.fail(`nothing installed in ${modulesDir}`, 1);
+        const named = rest.filter((a) => !a.startsWith("-"));
+        const targets = named.length > 0 ? named : ctx.vfs.readdir(modulesDir, ctx.cred).filter((n) => !n.startsWith("."));
+        let status = 0;
+        for (const name of targets) {
+          const dir3 = join(modulesDir, name);
+          if (!ctx.vfs.lexists(dir3)) {
+            ctx.warn(`npm warn ${name} is not installed`);
+            status = 1;
+            continue;
+          }
+          if (!rest.includes("--ignore-scripts")) await runLifecycleScripts(ctx, dir3, name, { quiet: true });
+          const linked = linkPackageBinaries(ctx, dir3, name, binDir);
+          const report = inspectPackage(ctx, dir3, name);
+          if (report.verdict !== "ok") {
+            for (const line of report.lines) ctx.stderr.write(`npm warn ${line}
+`);
+            status = 1;
+            continue;
+          }
+          for (const bin of linked) ctx.line(`${join(binDir, bin)} -> ${dir3}`);
+        }
+        return status;
+      }
       case "exec":
         return await runScript(ctx, root, rest.join(" "), [], readManifest(ctx, root)?.manifest ?? {});
       case "root":
-        ctx.line(join(root, "node_modules"));
+        ctx.line(isGlobal(rest) ? GLOBAL_MODULES : join(root, "node_modules"));
         return 0;
       case "prefix":
-        ctx.line(root);
+        ctx.line(isGlobal(rest) ? GLOBAL_PREFIX : root);
+        return 0;
+      case "bin":
+        ctx.line(isGlobal(rest) ? GLOBAL_BIN : join(root, "node_modules", ".bin"));
         return 0;
       case "config":
         if (rest[0] === "get") {
@@ -23090,7 +24453,7 @@ async function runScript(ctx, root, script, extraArgs, manifest) {
     npm_config_user_agent: `npm/${NPM_VERSION} node/${NODE_VERSION} linux x64`,
     INIT_CWD: ctx.cwd
   };
-  const commandLine = extraArgs.length ? `${script} ${extraArgs.map(quote).join(" ")}` : script;
+  const commandLine = extraArgs.length ? `${script} ${extraArgs.map(quote2).join(" ")}` : script;
   return await ctx.kernel.spawn(["/bin/sh", "-c", commandLine], {
     cwd: root,
     env: env2,
@@ -23101,7 +24464,7 @@ async function runScript(ctx, root, script, extraArgs, manifest) {
     stderr: ctx.stderr
   }).wait();
 }
-function quote(value) {
+function quote2(value) {
   return /^[A-Za-z0-9_@%+=:,./-]+$/.test(value) ? value : `'${value.replace(/'/g, `'\\''`)}'`;
 }
 function normalizeBinDirectories(ctx, root) {
@@ -23457,11 +24820,16 @@ function allCommands() {
     ...nodeCommands(),
     ...pythonCommands(),
     ...ffmpegCommands(),
+    ...wasmCommands(),
     ...packageCommands()
   ];
 }
+function allFormats() {
+  return [wasmFormat, ...nativeFormats()];
+}
 function installUserland(kernel) {
   kernel.installCommands(allCommands());
+  kernel.formats.registerAll(allFormats());
   const vfs = kernel.vfs;
   if (!vfs.lexists("/usr/bin/reset")) {
     vfs.writeFile("/usr/bin/reset", "#!/bin/sh\nprintf '\\033c'\n", { privileged: true, mode: 493 });
@@ -23606,15 +24974,15 @@ var Session = class {
   async run(command, opts = {}) {
     if (this.closed) throw new Error("session is closed");
     const combined = [];
-    const decoder7 = new TextDecoder();
+    const decoder8 = new TextDecoder();
     const stdout = new BufferSink((chunk) => {
-      const text = decoder7.decode(chunk, { stream: true });
+      const text = decoder8.decode(chunk, { stream: true });
       combined.push(text);
       opts.onStdout?.(text);
       this.hooks.onStdout?.(text);
     });
     const stderr = new BufferSink((chunk) => {
-      const text = decoder7.decode(chunk, { stream: true });
+      const text = decoder8.decode(chunk, { stream: true });
       combined.push(text);
       opts.onStderr?.(text);
       this.hooks.onStderr?.(text);
@@ -23950,15 +25318,15 @@ var Container = class _Container {
   }
   makeStdio(opts) {
     const combined = [];
-    const decoder7 = new TextDecoder();
+    const decoder8 = new TextDecoder();
     const stdout = new BufferSink((chunk) => {
-      const text = decoder7.decode(chunk, { stream: true });
+      const text = decoder8.decode(chunk, { stream: true });
       combined.push(text);
       opts.onStdout?.(text);
       this.hooks.onStdout?.(text);
     });
     const stderr = new BufferSink((chunk) => {
-      const text = decoder7.decode(chunk, { stream: true });
+      const text = decoder8.decode(chunk, { stream: true });
       combined.push(text);
       opts.onStderr?.(text);
       this.hooks.onStderr?.(text);