sandboxedjs 0.1.48 → 0.1.50

package/dist/{container-DyRF-bY0.d.ts → container-Dg8NwBc7.d.cts}

@@ -1,411 +1,4 @@
-/** The handle a pod's process manager returns. */
-interface ChildHandle {
-    pid: number;
-    state: "starting" | "running" | "exited";
-    exitCode: number | undefined;
-    on(event: "stdout" | "stderr" | "exit" | "rawmode", listener: (...args: any[]) => void): unknown;
-    exec(): void;
-    sendStdin(data: string): void;
-    /**
-     * Close the child's input.
-     *
-     * Without this a child that reads stdin to EOF — every filter, and every
-     * tool a library pipes into, `xsel` and `base64` alike — waits forever for
-     * an end that never comes, and the parent waits on its exit.
-     */
-    endStdin?(): void;
-    kill(signal?: string): void;
-}
-interface ChildSpawnConfig {
-    command: string;
-    args?: string[];
-    cwd?: string;
-    env?: Record<string, string>;
-    parentPid?: number;
-    /**
-     * The child was given the parent's streams (`stdio: "inherit"`).
-     *
-     * Its input is then the parent's terminal rather than a pipe that will end,
-     * which is the difference between a program that waits for what the user
-     * types and one that reads to end-of-input and stops.
-     */
-    inheritStdio?: boolean;
-    /**
-     * The child was told to ignore its input (`stdio: "ignore"`).
-     *
-     * It then has no input at all, so its stdin is closed at once rather than
-     * left open on a parent that will never write to it.
-     */
-    stdinIgnored?: boolean;
-}
-type SpawnChild = (config: ChildSpawnConfig) => ChildHandle;
-/**
- * Run a child to completion without returning to the event loop.
- *
- * Supplied only by a pod that can actually block — one whose guest runs on its
- * own thread. Where it is absent the synchronous entry points keep reporting
- * that they are unavailable, which is the honest answer for an in-realm pod.
- */
-type SyncSpawn = (request: {
-    command: string;
-    args: string[];
-    cwd: string;
-    env?: Record<string, string>;
-    input?: string;
-    inheritStdio?: boolean;
-}) => {
-    status: number | null;
-    stdout: string;
-    stderr: string;
-    signal: string | null;
-    error?: {
-        code?: string;
-        message: string;
-    };
-};
-declare function createChildProcessModule(spawnChild: SpawnChild, defaultCwd: () => string, syncSpawn?: SyncSpawn, defaultEnv?: () => Record<string, string>): Record<string, unknown>;
-
-/**
- * Clean-room contracts between SandboxedJS and its JavaScript runtime.
- *
- * These deliberately describe only behavior SandboxedJS consumes. Runtime
- * implementations may use Web Workers in browsers or worker_threads on Node.
- */
-
-interface VolumeStats {
-    totalBytes: number;
-    fileCount: number;
-    /** New runtime spelling. */
-    directoryCount?: number;
-    /** Compatibility spelling used by existing volume implementations. */
-    dirCount?: number;
-}
-interface VolumeStat {
-    mode: number;
-    size: number;
-    uid: number;
-    gid: number;
-    ino: number;
-    nlink: number;
-    atimeMs: number;
-    mtimeMs: number;
-    ctimeMs: number;
-    birthtimeMs: number;
-    isFile(): boolean;
-    isDirectory(): boolean;
-    isSymbolicLink(): boolean;
-}
-interface RuntimeVolume {
-    readFileSync(path: string): Uint8Array;
-    writeFileSync(path: string, data: string | Uint8Array): void;
-    appendFileSync(path: string, data: string | Uint8Array): void;
-    readdirSync(path: string): string[];
-    lstatSync(path: string): VolumeStat;
-    readlinkSync(path: string): string;
-    mkdirSync(path: string, options?: {
-        mode?: number;
-    }): void;
-    rmdirSync(path: string): void;
-    unlinkSync(path: string): void;
-    renameSync(from: string, to: string): void;
-    symlinkSync(target: string, path: string): void;
-    linkSync(existing: string, path: string): void;
-    truncateSync(path: string, length?: number): void;
-    chmodSync(path: string, mode: number): void;
-    lchmodSync(path: string, mode: number): void;
-    chownSync(path: string, uid: number, gid: number): void;
-    lchownSync(path: string, uid: number, gid: number): void;
-    utimesSync(path: string, atime: Date, mtime: Date): void;
-    getStats(): VolumeStats;
-}
-interface RuntimeProcessResult {
-    exitCode: number;
-    stdout: string;
-    stderr: string;
-}
-interface RuntimeProcess {
-    readonly completion: Promise<RuntimeProcessResult>;
-    /**
-     * `output` and `error` carry stdout and stderr; `exit` the code. `rawmode`
-     * reports the program turning terminal raw mode on or off, which a terminal
-     * needs so that it stops echoing input the program is drawing itself.
-     */
-    on(event: "output" | "error" | "exit" | "rawmode", listener: (...args: any[]) => void): this;
-    write(data: string): void;
-    kill(signal?: string): void;
-}
-interface RuntimeHttpResponse {
-    statusCode?: number;
-    statusMessage?: string;
-    headers?: Record<string, string>;
-    body?: string | Uint8Array | ArrayBuffer;
-}
-interface RuntimePackageInstaller {
-    install(name: string, version?: string, options?: Record<string, unknown>): Promise<unknown>;
-    installFromManifest(path: string, options?: Record<string, unknown>): Promise<unknown>;
-    /** Create a view that installs into another project root. */
-    forCwd?(cwd: string): RuntimePackageInstaller;
-}
-/** Where bytes written by an upgraded server inside the container come out. */
-interface RuntimeSocketPeer {
-    data(bytes: Uint8Array): void;
-    close(): void;
-}
-/** The caller's end of a connection opened with {@link RuntimePod.connect}. */
-interface RuntimeConnection {
-    send(bytes: Uint8Array): void;
-    close(): void;
-}
-/** The process-manager protocol a container's kernel bridge substitutes for. */
-interface RuntimeProcessManager {
-    spawn(config: ChildSpawnConfig): ChildHandle;
-}
-interface RuntimePod {
-    readonly volume: RuntimeVolume;
-    readonly packages: RuntimePackageInstaller;
-    readonly instanceId: string;
-    readonly processManager: RuntimeProcessManager;
-    readonly proxy: {
-        activePorts(instanceId?: string): number[];
-    };
-    spawn(command: string, args?: string[], options?: Record<string, unknown>): Promise<RuntimeProcess>;
-    request(port: number, init?: Record<string, unknown>): Promise<RuntimeHttpResponse>;
-    /**
-     * Open a connection that upgrades out of HTTP, or null if nothing takes one.
-     *
-     * Optional because a pod that only ever answers requests is still a usable
-     * pod — a caller treats the absence as "no WebSocket here" rather than as a
-     * broken implementation.
-     */
-    connect?(port: number, init: Record<string, unknown>, peer: RuntimeSocketPeer): RuntimeConnection | null;
-    snapshot(options?: Record<string, unknown>): unknown;
-    restore(snapshot: unknown, options?: Record<string, unknown>): Promise<void>;
-    teardown(): void;
-}
-
-type FileKind = "file" | "directory" | "symlink" | "chardev" | "blockdev" | "fifo" | "socket";
-/** Render as `drwxr-xr-x`, honouring setuid/setgid/sticky. */
-declare function formatMode(mode: number): string;
-/** Zero-padded octal permissions, as `stat -c %a`/`%04a` would show. */
-declare function octalMode(mode: number, width?: number): string;
-/**
- * Apply a `chmod` spec to an existing mode. Accepts octal (`755`, `0644`) and
- * the symbolic grammar (`u+rwx,go-w`, `a=r`, `+X`, `u+s`, `o+t`).
- *
- * @param isDir whether the target is a directory — needed for the `X` flag.
- */
-declare function applyChmod(spec: string, current: number, isDir: boolean, umask?: number): number;
-/** Parse the `umask` builtin's argument. */
-declare function parseUmask(spec: string): number;
-
-/**
- * The `Stats` object handed back by `Vfs.stat`. Shaped like `fs.Stats` so it
- * feels familiar, but with a real `st_mode` that carries the file-type bits
- * (which the underlying volume stores separately).
- */
-
-interface StatInit {
-    mode: number;
-    size: number;
-    uid: number;
-    gid: number;
-    ino: number;
-    nlink: number;
-    atimeMs: number;
-    mtimeMs: number;
-    ctimeMs: number;
-    birthtimeMs?: number;
-    dev?: number;
-    rdev?: number;
-    blksize?: number;
-}
-declare class Stats {
-    readonly mode: number;
-    readonly size: number;
-    readonly uid: number;
-    readonly gid: number;
-    readonly ino: number;
-    readonly nlink: number;
-    readonly dev: number;
-    readonly rdev: number;
-    readonly blksize: number;
-    readonly atimeMs: number;
-    readonly mtimeMs: number;
-    readonly ctimeMs: number;
-    readonly birthtimeMs: number;
-    constructor(init: StatInit);
-    get blocks(): number;
-    get atime(): Date;
-    get mtime(): Date;
-    get ctime(): Date;
-    get birthtime(): Date;
-    get kind(): FileKind;
-    isFile(): boolean;
-    isDirectory(): boolean;
-    isSymbolicLink(): boolean;
-    isCharacterDevice(): boolean;
-    isBlockDevice(): boolean;
-    isFIFO(): boolean;
-    isSocket(): boolean;
-    /** Permission bits only, with the type bits masked off. */
-    get perms(): number;
-}
-interface DirEntry {
-    name: string;
-    kind: FileKind;
-}
-
-/**
- * The container's virtual filesystem.
- *
- * Real file content lives in the RuntimePod's `MemoryVolume`, deliberately the
- * *same* volume the Node.js worker processes see — so a file written by `echo`
- * is readable by `require('fs')` inside a spawned script, and vice versa.
- *
- * On top of that volume this layer adds the parts a Linux userland expects and
- * the raw volume does not have: file-type bits in `st_mode`, permission and
- * ownership checks, an `O_*` open/fd table, and pluggable *virtual providers*
- * that synthesise `/proc`, `/sys` and `/dev` on demand.
- */
-
-/** The identity a filesystem operation runs as. */
-interface Cred {
-    uid: number;
-    gid: number;
-    groups: number[];
-    umask: number;
-}
-declare const ROOT_CRED: Cred;
-declare function makeCred(uid: number, gid: number, groups?: number[], umask?: number): Cred;
-/** A file that does not live in the volume — `/proc/uptime`, `/dev/null`, … */
-interface VirtualNode {
-    kind: FileKind;
-    /** Permission bits only; the type bits are added from `kind`. */
-    mode: number;
-    uid?: number;
-    gid?: number;
-    size?: number;
-    mtimeMs?: number;
-    /** Symlink target, when `kind === "symlink"`. */
-    target?: string;
-    read?(): Uint8Array | string;
-    write?(data: Uint8Array, append: boolean): void;
-    /** Directory listing, when `kind === "directory"`. */
-    list?(): string[];
-}
-/**
- * Supplies a subtree of synthetic files. `resolve` receives the path *relative*
- * to `root` ("" means the mount point itself) and returns null for misses.
- */
-interface VirtualProvider {
-    root: string;
-    resolve(rel: string): VirtualNode | null;
-    /**
-     * When true (the default) the provider owns its whole subtree and a miss is
-     * `ENOENT` — that is what `/proc` wants, so a dead pid does not resolve to a
-     * stale on-disk file. `/dev` and `/sys` set this to false so that synthetic
-     * nodes overlay a real directory users can still write into.
-     */
-    exclusive?: boolean;
-}
-interface WriteOptions {
-    mode?: number;
-    append?: boolean;
-    cred?: Cred;
-    /** Skip the permission check — used by kernel-internal writes. */
-    privileged?: boolean;
-}
-interface ResolveOptions {
-    cred?: Cred;
-    /** Follow a symlink in the final position. Off for `lstat`, `rm`, `chmod -h`. */
-    followFinal?: boolean;
-}
-declare class Vfs {
-    readonly volume: RuntimeVolume;
-    private readonly providers;
-    private nextVirtualIno;
-    private readonly virtualInos;
-    constructor(volume: RuntimeVolume);
-    addProvider(provider: VirtualProvider): void;
-    removeProvider(root: string): void;
-    /** The mount points currently served synthetically. */
-    get virtualRoots(): string[];
-    private lookupVirtual;
-    /** True when a miss at `abs` must be ENOENT rather than a volume lookup. */
-    private isUnderProvider;
-    /** Synthetic children a non-exclusive provider contributes to a directory. */
-    private virtualChildren;
-    private virtualIno;
-    /** True when `cred` may perform `mode` (R_OK/W_OK/X_OK) on a stat result. */
-    permitted(st: Stats, mode: number, cred: Cred): boolean;
-    private require;
-    /**
-     * Walk `abs` component by component, following symlinks and checking search
-     * (`+x`) permission on every directory along the way, exactly like `namei`.
-     *
-     * Returns the fully resolved absolute path. Does *not* require the final
-     * component to exist — callers decide whether a miss is fatal.
-     */
-    resolvePath(abs: string, opts?: ResolveOptions): string;
-    /** lstat that returns null instead of throwing, for internal probing. */
-    private tryLstat;
-    private readlinkRaw;
-    /** stat(2) — follows symlinks. */
-    stat(abs: string, opts?: {
-        cred?: Cred;
-    }): Stats;
-    /** lstat(2) — does not follow a symlink in the final position. */
-    lstat(abs: string): Stats;
-    private statFromVirtual;
-    exists(abs: string, cred?: Cred): boolean;
-    lexists(abs: string): boolean;
-    access(abs: string, mode?: number, cred?: Cred): void;
-    realpath(abs: string, cred?: Cred): string;
-    readFile(abs: string, cred?: Cred): Uint8Array;
-    readText(abs: string, cred?: Cred): string;
-    readdir(abs: string, cred?: Cred): string[];
-    /** True when the volume itself has a real directory at `abs`. */
-    private volumeHasDir;
-    readdirWithTypes(abs: string, cred?: Cred): DirEntry[];
-    readlink(abs: string, cred?: Cred): string;
-    writeFile(abs: string, data: Uint8Array | string, opts?: WriteOptions): void;
-    appendFile(abs: string, data: Uint8Array | string, opts?: WriteOptions): void;
-    truncate(abs: string, len?: number, cred?: Cred): void;
-    mkdir(abs: string, opts?: {
-        mode?: number;
-        recursive?: boolean;
-        cred?: Cred;
-    }): void;
-    private mkdirOne;
-    rmdir(abs: string, cred?: Cred): void;
-    unlink(abs: string, cred?: Cred): void;
-    /** Recursive delete, the engine behind `rm -r`. */
-    rmrf(abs: string, cred?: Cred): void;
-    private requireParentWrite;
-    rename(from: string, to: string, cred?: Cred): void;
-    copyFile(from: string, to: string, cred?: Cred): void;
-    symlink(target: string, linkPath: string, cred?: Cred): void;
-    link(existing: string, newPath: string, cred?: Cred): void;
-    chmod(abs: string, mode: number, cred?: Cred, follow?: boolean): void;
-    chown(abs: string, uid: number, gid: number, cred?: Cred, follow?: boolean): void;
-    utimes(abs: string, atimeMs: number, mtimeMs: number, cred?: Cred): void;
-    /** `touch` semantics: create when missing, otherwise bump the timestamps. */
-    touch(abs: string, cred?: Cred, timeMs?: number): void;
-    /** Depth-first walk yielding absolute paths. Symlinks are not followed. */
-    walk(abs: string, opts?: {
-        includeSelf?: boolean;
-        cred?: Cred;
-        maxDepth?: number;
-    }): Generator<string>;
-    /** Recursive copy used by `cp -r` and the container's `copyIn` helper. */
-    copyTree(from: string, to: string, cred?: Cred): void;
-    /** Free/used byte accounting for `df` and `du`. */
-    usage(abs?: string): {
-        files: number;
-        dirs: number;
-        bytes: number;
-    };
-}
+import { V as Vfs, C as Cred, e as RuntimePod, D as DirEntry, o as Stats } from './vfs-DzEcPbMY.cjs';
 
 /**
  * Byte streams for stdin/stdout/stderr, pipelines and redirections.
@@ -1443,6 +1036,84 @@ declare class Shell {
     reapJobs(): Job[];
 }
 
+/**
+ * What a Python runtime release says about itself.
+ *
+ * A manifest is how a host selects an interpreter build without guessing from
+ * a URL. It names the exact artifact, the ABI it was compiled against, and the
+ * capabilities it actually has — so a program that needs threads or native
+ * extensions can be told "not in this profile" instead of failing somewhere
+ * deep inside an import.
+ *
+ * The ABI identity is the part that must never be inferred. A build compiled
+ * against `sbx_host_v1` cannot be loaded by a kernel that speaks a different
+ * version, and finding that out at the first syscall rather than at load time
+ * turns a clear error into a corrupted run.
+ */
+declare const MANIFEST_FORMAT = "sandboxedjs-python-runtime";
+declare const MANIFEST_SCHEMA_VERSION = 1;
+/** Build profiles, as defined in docs/python/architecture.md. */
+type PythonProfile = "core" | "threaded-fixed" | "threaded-dynamic";
+interface PythonCapabilities {
+    /** Real Python threads. `core` builds have none, and must say so. */
+    threads: boolean;
+    /**
+     * How native extensions may arrive:
+     * `none` — no extension modules beyond the built-ins;
+     * `fixed` — curated extensions linked into the image;
+     * `dynamic` — side modules loaded at import time.
+     */
+    nativeExtensions: "none" | "fixed" | "dynamic";
+    /** `none`, `http` (kernel-controlled fetch), or `sockets` (virtual sockets). */
+    networking: "none" | "http" | "sockets";
+    /** `none`, or `spawn` — never `fork`, which cannot be honest here. */
+    processes: "none" | "spawn";
+    /** Where an environment survives: nowhere, memory only, or real storage. */
+    persistence: "none" | "memory" | "durable";
+}
+interface PythonRuntimeManifest {
+    format: typeof MANIFEST_FORMAT;
+    schemaVersion: number;
+    /** Stable identity of this build; also the cache key for its compiled module. */
+    runtimeId: string;
+    engine: "cpython-wasm";
+    /** The interpreter's own version, e.g. "3.13.5". */
+    pythonVersion: string;
+    profile: PythonProfile;
+    hostAbi: {
+        name: string;
+        version: number;
+    };
+    artifacts: {
+        /** The Emscripten loader module. Its `.wasm` and `.data` sit beside it. */
+        moduleUrl: string;
+        /** Optional integrity hashes, keyed by file name. */
+        hashes?: Record<string, string>;
+    };
+    capabilities: PythonCapabilities;
+}
+/**
+ * Check a manifest before anything is loaded from it.
+ *
+ * Every failure here is one that would otherwise surface much later and much
+ * less clearly — a missing capability as an ImportError, a wrong ABI as a
+ * corrupted syscall.
+ */
+declare function validateManifest(value: unknown): PythonRuntimeManifest;
+
+/**
+ * Which Python backend a container uses.
+ *
+ * The owned runtime is introduced behind an explicit choice rather than as a
+ * silent replacement: the two backends have genuinely different process
+ * semantics, and a container that switched between them on its own would
+ * change whether `sys.modules` is shared, whether `os.getpid()` varies, and
+ * what a failed import means. The old backend stays reachable until the parity
+ * gates in docs/python/release-gates.md pass.
+ */
+
+type PythonBackendName = "pyodide" | "sbx-cpython-wasm";
+
 /**
  * The CPython runtime: Pyodide, wired to the container the same way
  * the other runtimes are — filesystem, argv, environment and standard streams.
@@ -1477,7 +1148,20 @@ declare function configureCPython(options?: CPythonOptions): void;
 /** True when this host can start CPython at all. */
 declare function isCPythonAvailable(): Promise<boolean>;
 
-/** The existing Python CLI surface, backed exclusively by CPython/Pyodide. */
+/**
+ * The `python3` command.
+ *
+ * Two backends sit behind it. `pyodide` is the original integration: one
+ * interpreter cached per container, with each program given fresh globals —
+ * which is why `sys.modules` leaks between unrelated programs and every
+ * program reports the same PID (see docs/python/baseline-inventory.md).
+ * `sbx-cpython-wasm` is the owned distribution: CPython built from source, one
+ * interpreter per process, everything reached through the `sbx_host_v1` kernel
+ * ABI.
+ *
+ * The choice is explicit and per-container. The two have genuinely different
+ * process semantics, so switching silently would change what a program means.
+ */
 
 declare const PYTHON_VERSION = "3.13";
 interface PythonOptions {
@@ -1485,6 +1169,15 @@ interface PythonOptions {
     indexURL?: string;
     /** URL of pyodide.mjs, for browsers without package resolution. */
     pyodideURL?: string;
+    /**
+     * Which interpreter to run. Defaults to `pyodide` until the parity gates in
+     * docs/python/release-gates.md pass.
+     */
+    backend?: PythonBackendName;
+    /** The owned runtime's release manifest. Required by `sbx-cpython-wasm`. */
+    manifest?: PythonRuntimeManifest;
+    /** Where the built process worker is served from, for hosts that must say. */
+    workerUrl?: string;
 }
 declare function configurePython(options?: PythonOptions): void;
 declare const isPythonAvailable: typeof isCPythonAvailable;
@@ -1859,4 +1552,4 @@ declare class Container {
 /** Boot a container. The one function most callers need. */
 declare function createContainer(opts?: ContainerOptions): Promise<Container>;
 
-export { Pipe as $, FileInput as A, BufferSink as B, Container as C, type DirEntry as D, type ExecContext as E, type FileData as F, FileOutput as G, type GroupEntry as H, type HttpResponse as I, type InputStream as J, Kernel as K, type Job as L, type KernelOptions as M, type Node as N, type OutputStream as O, type ListeningPort as P, type MountEntry as Q, type RuntimeVolume as R, Shell as S, type NetInterface as T, type NetworkOptions as U, Vfs as V, NetworkStack as W, NullInput as X, NullOutput as Y, PYTHON_VERSION as Z, type PasswdEntry as _, type ShellIO as a, Process as a0, type ProcessKind as a1, type ProcessOptions as a2, type ProcessState as a3, ProcessTable as a4, type PythonOptions as a5, ROOT_CRED as a6, type ResolvedExecutable as a7, type RunOptions as a8, type RunResult as a9, expandWords as aA, formatMode as aB, isCPythonAvailable as aC, isPythonAvailable as aD, makeCred as aE, octalMode as aF, parseUmask as aG, resetPidCounter as aH, shellQuote as aI, type RuntimeProcessManager as aa, type RuntimeProcessResult as ab, type SessionInit as ac, type SessionResult as ad, type SessionRunOptions as ae, ShellExit as af, type ShellInit as ag, type ShellOptions as ah, type SpawnHandle as ai, Stats as aj, type Stdio as ak, TeeOutput as al, UserDatabase as am, Variables as an, type VirtualNode as ao, type VirtualProvider as ap, type WriteOptions as aq, applyChmod as ar, braceExpand as as, captureStdio as at, configureCPython as au, configurePython as av, createChildProcessModule as aw, createContext as ax, defineCommand as ay, expandWord as az, Session as b, type Cred as c, type Command as d, type VolumeStat as e, type VolumeStats as f, type RuntimeHttpResponse as g, type SpawnChild as h, type SyncSpawn as i, type RuntimePod as j, type RuntimePackageInstaller as k, type ChildSpawnConfig as l, type ChildHandle as m, type RuntimeProcess as n, type RuntimeSocketPeer as o, type RuntimeConnection as p, createContainer as q, type CPythonOptions as r, CallbackSink as s, CommandRegistry as t, ContainerFs as u, type ContainerOptions as v, type ContextInit as w, type Env as x, type ExecOptions as y, type ExecResult as z };
+export { type SessionResult as $, type ProcessKind as A, BufferSink as B, Container as C, type ProcessOptions as D, type ExecContext as E, type FileData as F, type GroupEntry as G, type HttpResponse as H, type InputStream as I, type Job as J, Kernel as K, type ListeningPort as L, MANIFEST_FORMAT as M, type Node as N, type OutputStream as O, PYTHON_VERSION as P, type ProcessState as Q, ProcessTable as R, Shell as S, type PythonCapabilities as T, type PythonOptions as U, type PythonProfile as V, type PythonRuntimeManifest as W, type ResolvedExecutable as X, type RunOptions as Y, type RunResult as Z, type SessionInit as _, type ShellIO as a, type SessionRunOptions as a0, ShellExit as a1, type ShellInit as a2, type ShellOptions as a3, type SpawnHandle as a4, type Stdio as a5, TeeOutput as a6, UserDatabase as a7, Variables as a8, braceExpand as a9, captureStdio as aa, configureCPython as ab, configurePython as ac, createContext as ad, defineCommand as ae, expandWord as af, expandWords as ag, isCPythonAvailable as ah, isPythonAvailable as ai, resetPidCounter as aj, shellQuote as ak, validateManifest as al, Session as b, type Command as c, createContainer as d, type CPythonOptions as e, CallbackSink as f, CommandRegistry as g, ContainerFs as h, type ContainerOptions as i, type ContextInit as j, type Env as k, type ExecOptions as l, type ExecResult as m, FileInput as n, FileOutput as o, type KernelOptions as p, MANIFEST_SCHEMA_VERSION as q, type MountEntry as r, type NetInterface as s, type NetworkOptions as t, NetworkStack as u, NullInput as v, NullOutput as w, type PasswdEntry as x, Pipe as y, Process as z };