sandboxedjs 0.1.8 → 0.1.9

package/dist/index.d.cts

@@ -633,6 +633,8 @@ declare function createContext(init: ContextInit): ExecContext;
  * container can execute it" is far more use than `Exec format error`.
  */
 
+/** How many bytes of the file head a handler is given to identify it. */
+declare const MAGIC_BYTES = 256;
 interface ExecFormat {
     /** Short identifier, e.g. `wasi`. Shown by `file` and in diagnostics. */
     readonly name: string;
@@ -2026,6 +2028,539 @@ declare function isPythonAvailable(): Promise<boolean>;
 
 declare const NPM_VERSION = "10.9.0";
 
+/**
+ * WebAssembly as an executable format.
+ *
+ * This is what makes a `.wasm` file in `$PATH` a program. The format handler
+ * registered here is asked by the kernel whenever a file starts with `\0asm`,
+ * so a WASI binary is run through exactly the same path as `grep` or a shell
+ * script: `chmod +x jq.wasm && ./jq.wasm .name < data.json` works, and so does
+ * dropping it in `/usr/local/bin` and calling it `jq`.
+ *
+ * Nothing here knows the name of a single program. What it knows is how to read
+ * a module's import section and tell which *convention* the module was built
+ * for, because that is what decides whether it can run:
+ *
+ *  - `wasi_snapshot_preview1` — a command module. Runs, on the container's own
+ *    filesystem. This covers `wasm32-wasi` C/C++/Rust/Zig and Go's `wasip1`.
+ *  - `wasi:cli/*` — a preview 2 component. Not an instantiable module at all;
+ *    it needs to be transpiled first, and saying so beats a type error.
+ *  - `env` + a JS glue file — Emscripten or wasm-bindgen output, which is only
+ *    half a program; the loader beside it is the entry point, not this file.
+ *  - `gojs` — `GOOS=js`, which needs Go's `wasm_exec.js` harness.
+ *
+ * Each of those gets a specific diagnosis instead of "Exec format error", which
+ * matters more than it sounds: the difference between "this will never work"
+ * and "you are holding it wrong" is most of the debugging.
+ */
+
+declare function isWasmBinary(head: Uint8Array): boolean;
+type WasmFlavour = "wasi" | "wasi-component" | "emscripten" | "wasm-bindgen" | "go-js" | "core";
+interface WasmAnalysis {
+    flavour: WasmFlavour;
+    /** Distinct import module names, in declaration order. */
+    modules: string[];
+    /** True when the module wants a memory it does not own. */
+    importsMemory: boolean;
+    /** True when the imported memory is shared, i.e. the module wants threads. */
+    wantsThreads: boolean;
+    exports: string[];
+}
+/** Classify a compiled module by what it imports and exports. */
+declare function analyse(module: WebAssembly.Module): WasmAnalysis;
+/** Forget cached modules. Exposed for tests and for long-lived hosts. */
+declare function clearWasmCache(): void;
+/**
+ * Run a WASI command module.
+ *
+ * `argv[0]` is the name the program was invoked as, so a module symlinked to
+ * two names can tell which one it is — busybox-style multi-call binaries
+ * depend on it.
+ */
+declare function runWasi(ctx: ExecContext, path: string, argv0?: string): Promise<number>;
+declare const wasmFormat: ExecFormat;
+
+/**
+ * A WASI `preview1` host implemented over the container's filesystem.
+ *
+ * This is the counterpart to `emscripten-fs.ts`, for the other half of the
+ * WebAssembly world. Emscripten programs come with their own JavaScript runtime
+ * and are handed a filesystem backend; WASI programs come as a bare `.wasm`
+ * module and expect the *host* to be the operating system. So this file is that
+ * operating system: every `wasi_snapshot_preview1` import a compiled program can
+ * ask for, answered out of the same `Vfs` the shell, Node.js and Python use.
+ *
+ * The consequence is the point of the whole exercise. Anything on earth that
+ * compiles to `wasm32-wasi` — and that is most C, C++, Rust, Zig and Go code
+ * that does not need threads or sockets — becomes a program this container can
+ * run, without the container knowing anything about it. `path_open("data.csv")`
+ * from a Rust binary opens the same file `echo > data.csv` just created.
+ *
+ * Deliberate limits, all of which report a real errno rather than crashing:
+ *  - no threads: `wasi-threads` modules fail at instantiation, not mid-run;
+ *  - no sockets: `sock_*` returns ENOTSUP, since the container has no raw ones;
+ *  - `poll_oneoff` handles clock subscriptions only, which is what `sleep` and
+ *    most timeouts actually use.
+ *
+ * Everything is synchronous, because WASI is. Standard input is therefore read
+ * to completion before the module starts, the same compromise the Emscripten
+ * mount makes.
+ */
+
+/** Thrown by `proc_exit` to unwind out of the module. */
+declare class WasiExit extends Error {
+    readonly code: number;
+    constructor(code: number);
+}
+interface WasiOptions {
+    vfs: Vfs;
+    cred: Cred;
+    /** Full argv, including argv[0]. */
+    args: string[];
+    env: Record<string, string | undefined>;
+    cwd: string;
+    /** Standard input, already read to completion. */
+    stdin?: Uint8Array;
+    /** Called with each write to fd 1 and fd 2. */
+    stdout: (bytes: Uint8Array) => void;
+    stderr: (bytes: Uint8Array) => void;
+    /**
+     * Directories to preopen, as `guestName -> containerPath`. Programs can only
+     * reach paths beneath a preopen, which is WASI's sandbox and is left intact:
+     * the default grants `/`, so the container's own permissions do the limiting,
+     * but a caller can hand over a single directory instead.
+     */
+    preopens?: Record<string, string>;
+    /** Monotonic-ish clock, so tests can pin time. */
+    now?: () => number;
+    /** Fills a buffer for `random_get`. */
+    randomFill?: (buffer: Uint8Array) => void;
+}
+/**
+ * A WASI preview1 implementation bound to one process.
+ *
+ * Construct it, hand `imports` to `WebAssembly.instantiate`, then call
+ * `bind(instance)` before starting the module so the host can reach its memory.
+ */
+declare class WasiPreview1 {
+    private memory;
+    private readonly fds;
+    private nextFd;
+    private readonly opts;
+    private readonly now;
+    private readonly randomFill;
+    /** Set once `proc_exit` has been seen, so the caller can tell exit 0 from a
+     * module that simply returned. */
+    exited: number | null;
+    constructor(opts: WasiOptions);
+    /** Give the host access to the instantiated module's memory. */
+    bind(instance: WebAssembly.Instance): void;
+    private get view();
+    private get bytes();
+    private readString;
+    /** Scatter/gather list, as `fd_read` and `fd_write` take. */
+    private iovecs;
+    /**
+     * 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.
+     */
+    private resolveAt;
+    private errnoOf;
+    private filetypeOf;
+    /** Write a 64-byte `filestat` for `path`. */
+    private writeFilestat;
+    /** Persist an open file's buffer back to the filesystem. */
+    private flush;
+    /**
+     * 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(): WebAssembly.Imports;
+    private syscalls;
+    private readInto;
+    private writeFrom;
+    private allocateFd;
+    private envPairs;
+    /** Flush and drop every open descriptor. Safe to call twice. */
+    close(): void;
+}
+
+/**
+ * Native executable formats other than the one this container can execute.
+ *
+ * x86-64 Linux binaries are handled in `x86/`, on an emulated CPU. Mach-O and
+ * PE are a different matter: they are not just machine code but a different
+ * operating system's process model, loader and system-call interface, and none
+ * of that is worth building for programs that were never going to be in a
+ * Linux container anyway.
+ *
+ * So these handlers parse enough of each header to name the thing and say what
+ * would work instead. `command not found` sends someone hunting for a missing
+ * `$PATH` entry when the real answer is that they installed a macOS binary;
+ * `Exec format error` is technically right and practically useless.
+ */
+
+declare const machoFormat: ExecFormat;
+declare const peFormat: ExecFormat;
+declare function nativeFormats(): ExecFormat[];
+
+declare class Memory {
+    private readonly pages;
+    /** Bump pointer for anonymous `mmap`, below the stack and above the heap. */
+    mmapNext: number;
+    /** Current program break, set by the loader and moved by `brk`. */
+    brk: number;
+    private page;
+    /** Make `[address, address+length)` readable and writable. */
+    map(address: number, length: number): void;
+    unmap(address: number, length: number): void;
+    isMapped(address: number): boolean;
+    /** Reserve `length` bytes of anonymous space, page-aligned. */
+    mmapAnonymous(length: number): number;
+    read8(address: number): number;
+    write8(address: number, value: number): void;
+    /**
+     * Read `size` bytes little-endian. Split across pages byte by byte rather
+     * than assuming an access stays inside one — unaligned loads that straddle a
+     * page boundary are entirely legal on x86.
+     */
+    read(address: number, size: number): bigint;
+    write(address: number, size: number, value: bigint): void;
+    readBytes(address: number, length: number): Uint8Array;
+    writeBytes(address: number, bytes: Uint8Array): void;
+    /** Read a NUL-terminated string, as every path argument to a syscall is. */
+    readCString(address: number, limit?: number): string;
+    writeCString(address: number, text: string): number;
+    get pageCount(): number;
+}
+
+/**
+ * An x86-64 interpreter.
+ *
+ * Decode, execute, repeat. No JIT, no basic-block caching — correctness first,
+ * because a subtly wrong flag is far more expensive to chase than a slow loop.
+ *
+ * Register values are BigInt. That is the slow choice and a deliberate one:
+ * x86-64 semantics are full of 64-bit shifts, sign extensions and
+ * multiplications whose high half matters, and splitting every value into two
+ * 32-bit halves multiplies the number of places a bug can hide by roughly the
+ * number of instructions. Addresses stay as JavaScript numbers, since they fit
+ * in 48 bits and are used on every memory access.
+ *
+ * What is implemented is the integer instruction set a compiler actually emits
+ * for ordinary code: the arithmetic and logic groups, moves and sign/zero
+ * extensions, LEA, the jump/call/return family, conditional moves and sets,
+ * shifts and rotates, multiply and divide, the string operations with their
+ * REP prefixes, the bit-test and bit-scan instructions, CMPXCHG and XADD.
+ * Anything outside that raises `UnsupportedInstruction`, which names the
+ * opcode and where it was found rather than failing silently.
+ */
+
+interface CpuOptions {
+    memory: Memory;
+    /** Called on the `syscall` instruction; reads and writes registers directly. */
+    onSyscall: (cpu: Cpu) => void | Promise<void>;
+    /** Abort after this many instructions, so a runaway guest cannot hang the host. */
+    instructionLimit?: number;
+}
+declare class Cpu {
+    readonly memory: Memory;
+    readonly regs: BigUint64Array<ArrayBuffer>;
+    rip: number;
+    cf: boolean;
+    zf: boolean;
+    sf: boolean;
+    of: boolean;
+    pf: boolean;
+    af: boolean;
+    df: boolean;
+    /** `%fs` base, which is where thread-local storage lives on x86-64 Linux. */
+    fsBase: number;
+    gsBase: number;
+    /**
+     * The sixteen 128-bit vector registers, split into halves.
+     *
+     * Not optional extras: a compiler zeroes memory with `xorps`/`movups` and
+     * finds a NUL byte with `pcmpeqb`/`pmovmskb`, so ordinary code reaches for
+     * these within the first hundred instructions. Only the moves, the bitwise
+     * operations and the byte compares are implemented — the arithmetic that
+     * makes SSE interesting for numerics is not, and raises the usual error.
+     */
+    readonly xmmLo: BigUint64Array<ArrayBuffer>;
+    readonly xmmHi: BigUint64Array<ArrayBuffer>;
+    instructions: number;
+    private readonly limit;
+    private readonly onSyscall;
+    private rex;
+    private hasRex;
+    private opSize;
+    private addrSize;
+    private rep;
+    private opcodeStart;
+    constructor(opts: CpuOptions);
+    get(index: number): bigint;
+    set(index: number, value: bigint): void;
+    private fetch8;
+    private fetch;
+    private fetchSigned;
+    /**
+     * Read a register at a given width.
+     *
+     * The 8-bit encodings are the awkward part: with no REX prefix, indices 4–7
+     * name AH/CH/DH/BH — the *high* byte of the first four registers — while any
+     * REX prefix at all reassigns them to SPL/BPL/SIL/DIL.
+     */
+    private readReg;
+    private writeReg;
+    private modrm;
+    /** Decode a ModRM byte, resolving the effective address when there is one. */
+    private decodeModrm;
+    private ripRelative;
+    /**
+     * Finish a RIP-relative address once the whole instruction has been decoded.
+     * Called by the operand accessors, which run after any immediate is read.
+     */
+    private effectiveAddress;
+    private readRm;
+    private writeRm;
+    private setLogicFlags;
+    private setAddFlags;
+    private setSubFlags;
+    /** Evaluate one of the sixteen condition codes shared by Jcc/SETcc/CMOVcc. */
+    private condition;
+    push(value: bigint): void;
+    pop(): bigint;
+    /**
+     * Run until the guest exits.
+     *
+     * Yields to the event loop periodically: the interpreter is synchronous, and
+     * without this a long-running guest would block the host completely.
+     */
+    run(): Promise<number>;
+    /**
+     * Execute one instruction. Returns a promise only when the instruction was a
+     * syscall that needs to await, so the common path allocates nothing.
+     */
+    step(): Promise<void> | null;
+    /** Set by an `fs:`/`gs:` prefix, consumed by the next memory operand. */
+    private segmentBase;
+    private takeSegment;
+    private execute;
+    /**
+     * Read an immediate that follows the ModRM byte without disturbing the
+     * pending RIP-relative displacement.
+     *
+     * x86 puts the immediate after the address bytes but resolves RIP-relative
+     * addresses against the end of the *whole* instruction, so the immediate has
+     * to be consumed first and the address computed afterwards.
+     */
+    private peekImmediate;
+    private applyArith;
+    private shift;
+    private setShiftFlags;
+    private group3;
+    /**
+     * MOVS/STOS/LODS/SCAS/CMPS, with the REP prefixes.
+     *
+     * These are how a compiler open-codes `memcpy`, `memset` and `strlen`, so a
+     * program that never calls libc still leans on them heavily.
+     */
+    private stringOp;
+    private executeTwoByte;
+    private readXmmRm;
+    private writeXmmRm;
+    /** Byte `index` of a 128-bit value held as two halves. */
+    private static byteOf;
+    private static fromBytes;
+    /** Shift each element of a vector register: /2 logical right, /4 arithmetic right, /6 left. */
+    private packedShift;
+    private executeSse;
+    /**
+     * CPUID, reporting a deliberately plain processor.
+     *
+     * Advertising SSE4.2 or AVX would be a trap: glibc's IFUNC resolvers select
+     * string routines by feature bit, and would immediately pick vector code
+     * this interpreter does not implement. Claiming the x86-64 baseline steers
+     * every such resolver to the generic path.
+     */
+    private cpuid;
+    /** A snapshot for diagnostics when something goes wrong. */
+    describe(): string;
+}
+
+/**
+ * Cooperative threads for the emulated machine.
+ *
+ * The interpreter is one JavaScript loop with one register file, so there is no
+ * parallelism to be had. But `clone` cannot simply fail, and it cannot simply
+ * lie either: a Go program launches a monitor thread during startup and treats
+ * a failed `clone` as fatal, while a `clone` that returns a thread id nothing
+ * ever schedules leaves the main thread spinning in `FUTEX_WAIT` on a wake-up
+ * that can never arrive. Both were observed before this existed.
+ *
+ * So threads are real, just not simultaneous. Each holds a saved copy of the
+ * register file, and the scheduler swaps contexts at the points where a thread
+ * cannot make progress anyway — `futex` waits, `sched_yield`, `nanosleep`. That
+ * is enough for the usual shapes: a runtime that wants a background thread it
+ * never waits on, a worker that blocks on a queue, a mutex handed between two
+ * threads.
+ *
+ * What it cannot do is preempt. A thread that spins on a memory location
+ * without ever entering the kernel keeps the machine to itself, exactly as a
+ * cooperative scheduler implies.
+ */
+
+declare class Scheduler {
+    private readonly cpu;
+    private readonly threads;
+    private current;
+    private nextId;
+    constructor(cpu: Cpu);
+    get currentId(): number;
+    get count(): number;
+    /**
+     * Start a new thread at the caller's return address.
+     *
+     * A cloned thread resumes exactly where its parent is — immediately after the
+     * `syscall` instruction — with its own stack and `rax` of zero, which is how
+     * the child tells itself apart from the parent.
+     */
+    spawn(stackPointer: bigint, tlsBase: number, setTls: boolean): number;
+    /** Park the running thread on a futex, and run something else. */
+    wait(address: number, timeoutMs: number, now: number): boolean;
+    /** Make up to `count` threads parked on `address` runnable. Returns how many. */
+    wake(address: number, count: number): number;
+    /** Retire the running thread. Returns false when it was the last one. */
+    exit(now: number): boolean;
+    /**
+     * Switch to the next runnable thread.
+     *
+     * Returns false when there is nothing else to run — the caller then has to
+     * decide whether that is a finished program or a deadlock.
+     */
+    yieldNow(now: number): boolean;
+    /** True when every thread is parked — a genuine deadlock rather than a wait. */
+    get allBlocked(): boolean;
+}
+
+/**
+ * The Linux x86-64 syscall interface, served from the container's filesystem.
+ *
+ * This is the same idea as `wasi-preview1.ts` one layer down. WASI programs ask
+ * for `path_open`; native Linux programs execute the `syscall` instruction with
+ * a number in `rax` and arguments in `rdi, rsi, rdx, r10, r8, r9`, and expect a
+ * result — or a negative errno — back in `rax`. Underneath, both end up in the
+ * same `Vfs`, which is what lets an emulated binary read a file the shell wrote.
+ *
+ * Choosing this as the boundary is the whole design. Above it sits libc, with
+ * two thousand symbols, IFUNC resolvers and symbol versioning; there is no way
+ * to stand in front of that without already emulating instructions. Below it
+ * there are about eighty calls that matter, and they have been stable for
+ * decades. So libc runs as the machine code it is, and only its syscalls are
+ * answered here.
+ */
+
+interface LinuxOptions {
+    vfs: Vfs;
+    cred: Cred;
+    cwd: string;
+    memory: Memory;
+    stdin: Uint8Array;
+    stdout: (bytes: Uint8Array) => void;
+    stderr: (bytes: Uint8Array) => void;
+    hostname: string;
+    now: () => number;
+    /** Names every syscall the guest makes, for working out where it stalls. */
+    trace?: (line: string) => void;
+}
+declare class LinuxSyscalls {
+    private readonly files;
+    private nextFd;
+    private stdinPosition;
+    private cwd;
+    readonly opts: LinuxOptions;
+    /** Syscall numbers the guest asked for that are not implemented. */
+    readonly unimplemented: Set<number>;
+    /**
+     * Descriptors with no file behind them — epoll sets and eventfds. Tracked so
+     * `close` accepts them and `epoll_ctl` can tell a real one from a wrong one.
+     */
+    private readonly pseudoFds;
+    /** Threads the guest believes it started; see the `clone` case. */
+    threadsRequested: number;
+    constructor(opts: LinuxOptions);
+    /** Thread scheduler, attached once the CPU exists. */
+    scheduler: Scheduler | null;
+    /**
+     * Set by a syscall that switched threads. The result register then belongs to
+     * the thread we switched *to*, and must not be overwritten with ours.
+     */
+    private switched;
+    /** Entry point handed to the CPU. */
+    handle: (cpu: Cpu) => void;
+    private errnoOf;
+    private resolve;
+    private dispatch;
+    private writeTo;
+    private flush;
+    private open;
+    /** Fill a 144-byte `struct stat`. */
+    private stat;
+    /** `fstat` on stdin/stdout/stderr, which are character devices. */
+    private statCharDevice;
+    private getdents64;
+    private writeBounded;
+    /** `struct utsname`: six fixed 65-byte character arrays. */
+    private uname;
+    /** Persist everything still open. Called when the guest exits. */
+    close(): void;
+}
+
+/**
+ * Native x86-64 Linux binaries, as an executable format.
+ *
+ * The kernel sees `\x7fELF`, hands the file here, and this boots a machine for
+ * it: memory, a CPU, a Linux syscall layer over the container's filesystem, and
+ * the process image a program expects at `_start`. From the guest's point of
+ * view it is running on Linux. From the shell's point of view it is a command.
+ *
+ * Static binaries — `CGO_ENABLED=0 go build`, Rust's `musl` target, anything
+ * linked with `-static` — need nothing else, because everything they call is
+ * inside them and everything below that is a syscall.
+ *
+ * A dynamically linked binary needs its loader, and this will use a real one:
+ * if `PT_INTERP` names a file that exists in the container, both images are
+ * mapped and control goes to the loader, exactly as the kernel does it. That is
+ * why `ld-linux-x86-64.so.2` and `libc.so.6` are not simulated — they are
+ * ordinary x86-64 code, and a machine that can run the program can run them.
+ * Copy them in and dynamic binaries work; leave them out and the failure says
+ * precisely which file was missing.
+ */
+
+interface RunElfOptions {
+    /** Stop after this many instructions rather than spinning forever. */
+    instructionLimit?: number;
+    /** Called with every syscall, for diagnosing where a program stalls. */
+    trace?: (line: string) => void;
+}
+/**
+ * Load and run an x86-64 Linux binary.
+ *
+ * Returns the guest's exit status, or throws with something specific about why
+ * it could not start — a missing loader, an instruction outside the implemented
+ * set, or a wild memory access.
+ */
+declare function runElf(ctx: ExecContext, path: string, opts?: RunElfOptions): Promise<number>;
+/**
+ * The ELF handler. Unlike the stub it replaces, this one runs the file.
+ */
+declare const elfFormat: ExecFormat;
+declare function x86Commands(): Command[];
+
 /**
  * sandboxedjs — a Linux-like container that runs entirely inside Node.js.
  *
@@ -2044,4 +2579,4 @@ declare const NPM_VERSION = "10.9.0";
  * ```
  */
 
-export { ArithError, BufferSink, CallbackSink, type Command, CommandRegistry, Container, ContainerFs, type ContainerOptions, type ContextInit, type Cred, type DirEntry, ERRNO, type Env, type ErrnoCode, type ExecContext, type ExecOptions, type ExecResult, FileInput, FileOutput, type GroupEntry, type HttpResponse, IncompleteInputError, type InputStream, type Job, KERNEL_NAME, KERNEL_RELEASE, Kernel, type KernelOptions, type ListeningPort, type MountEntry, NODE_VERSION, NPM_VERSION, type NetInterface, type NetworkOptions, NetworkStack, NullInput, NullOutput, OS_RELEASE, type OutputStream, PYTHON_VERSION, type PasswdEntry, Pipe, Process, type ProcessKind, type ProcessOptions, type ProcessState, ProcessTable, ROOT_CRED, type ResolvedExecutable, type RootfsOptions, type RunOptions, type RunResult, SIGNALS, SIGNAL_NAMES, Session, type SessionInit, type SessionResult, type SessionRunOptions, Shell, ShellExit, type ShellIO, type ShellInit, Lexer as ShellLexer, type ShellOptions, ShellSyntaxError, type SpawnHandle, Stats, type Stdio, SysError, TeeOutput, Terminal, type TerminalOptions, UserDatabase, Variables, Vfs, type VirtualNode, type VirtualProvider, type WriteOptions, allCommands, applyChmod, braceExpand, buildRootfs, builtinNames, captureStdio, createContainer, createContext, createContainer as default, defineCommand, evalArith, exitCodeForSignal, expandPrompt, expandWord, expandWords, fnmatch, formatMode, getBuiltin, glob, globToRegex, hasMagic, installUserland, isBuiltinName, isPythonAvailable, isSysError, makeCred, normalizeSignal, octalMode, parse as parseShell, parseUmask, path as posixPath, resetPidCounter, shellQuote, strerror, unameInfo };
+export { ArithError, BufferSink, CallbackSink, type Command, CommandRegistry, Container, ContainerFs, type ContainerOptions, type ContextInit, type Cred, type DirEntry, ERRNO, type Env, type ErrnoCode, type ExecContext, type ExecFormat, ExecFormatRegistry, type ExecOptions, type ExecResult, FileInput, FileOutput, type GroupEntry, Memory as GuestMemory, type HttpResponse, IncompleteInputError, type InputStream, type Job, KERNEL_NAME, KERNEL_RELEASE, Kernel, type KernelOptions, LinuxSyscalls, type ListeningPort, MAGIC_BYTES, type MountEntry, NODE_VERSION, NPM_VERSION, type NetInterface, type NetworkOptions, NetworkStack, NullInput, NullOutput, OS_RELEASE, type OutputStream, PYTHON_VERSION, type PasswdEntry, Pipe, Process, type ProcessKind, type ProcessOptions, type ProcessState, ProcessTable, ROOT_CRED, type ResolvedExecutable, type RootfsOptions, type RunOptions, type RunResult, SIGNALS, SIGNAL_NAMES, Session, type SessionInit, type SessionResult, type SessionRunOptions, Shell, ShellExit, type ShellIO, type ShellInit, Lexer as ShellLexer, type ShellOptions, ShellSyntaxError, type SpawnHandle, Stats, type Stdio, SysError, TeeOutput, Terminal, type TerminalOptions, UserDatabase, Variables, Vfs, type VirtualNode, type VirtualProvider, WasiExit, type WasiOptions, WasiPreview1, type WasmAnalysis, type WasmFlavour, type WriteOptions, Cpu as X86Cpu, allCommands, analyse as analyseWasm, applyChmod, braceExpand, buildRootfs, builtinNames, captureStdio, clearWasmCache, createContainer, createContext, createContainer as default, defineCommand, elfFormat, evalArith, exitCodeForSignal, expandPrompt, expandWord, expandWords, fnmatch, formatMode, getBuiltin, glob, globToRegex, hasMagic, installUserland, isBuiltinName, isPythonAvailable, isSysError, isWasmBinary, machoFormat, makeCred, nativeFormats, normalizeSignal, octalMode, parse as parseShell, parseUmask, peFormat, path as posixPath, resetPidCounter, runElf, runWasi, shellQuote, strerror, unameInfo, wasmFormat, x86Commands };