sbox-sdk 0.0.2

package/dist/memory/index.d.ts

@@ -0,0 +1,57 @@
+import type { Preview, SandboxProvider, SandboxState } from "../adapter/index.js";
+export interface MemoryOptions {
+    /** Hide native fs methods to force the core's exec-based polyfills. */
+    bareFs?: boolean;
+    idPrefix?: string;
+}
+declare const MEMORY_CAPS: {
+    readonly background: "native";
+    readonly codeInterpreter: "unsupported";
+    readonly egressControl: "unsupported";
+    readonly exposePort: "emulated";
+    readonly filesUpload: "native";
+    readonly filesWatch: "unsupported";
+    readonly fork: "native";
+    readonly gpu: "unsupported";
+    readonly killProcess: "native";
+    readonly list: "native";
+    readonly metrics: "unsupported";
+    readonly pause: "native";
+    readonly privatePreview: "unsupported";
+    readonly proxiedFetch: "unsupported";
+    readonly pty: "unsupported";
+    readonly region: "unsupported";
+    readonly secretsVault: "unsupported";
+    readonly setTimeout: "native";
+    readonly snapshot: "native";
+    readonly ssh: "unsupported";
+    readonly statefulKernel: "unsupported";
+    readonly stdin: "unsupported";
+    readonly stop: "native";
+    readonly streaming: "native";
+    readonly volumes: "unsupported";
+};
+export type MemoryCaps = typeof MEMORY_CAPS;
+interface MemSandbox {
+    id: string;
+    files: Map<string, Uint8Array>;
+    dirs: Set<string>;
+    env: Record<string, string>;
+    metadata: Record<string, string>;
+    state: SandboxState;
+    createdAt: Date;
+    ports: Map<number, Preview>;
+    procCounter: number;
+    processes: Map<string, {
+        cmd: string;
+    }>;
+    snapshots: Map<string, {
+        files: Map<string, Uint8Array>;
+        dirs: Set<string>;
+    }>;
+    snapCounter: number;
+}
+export type MemoryRaw = MemSandbox;
+export declare function memory(opts?: MemoryOptions): SandboxProvider<MemoryCaps, MemoryRaw>;
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/memory/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/memory/index.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAUV,OAAO,EAEP,eAAe,EAEf,YAAY,EAEb,MAAM,qBAAqB,CAAC;AAE7B,MAAM,WAAW,aAAa;IAC5B,uEAAuE;IACvE,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;CA0BiB,CAAC;AAEnC,MAAM,MAAM,UAAU,GAAG,OAAO,WAAW,CAAC;AAU5C,UAAU,UAAU;IAClB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;IAC/B,IAAI,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IAClB,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC5B,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACjC,KAAK,EAAE,YAAY,CAAC;IACpB,SAAS,EAAE,IAAI,CAAC;IAChB,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC5B,WAAW,EAAE,MAAM,CAAC;IACpB,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE;QAAE,GAAG,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACxC,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE;QAAE,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;QAAC,IAAI,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;KAAE,CAAC,CAAC;IAC9E,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,MAAM,SAAS,GAAG,UAAU,CAAC;AA0XnC,wBAAgB,MAAM,CACpB,IAAI,GAAE,aAAkB,GACvB,eAAe,CAAC,UAAU,EAAE,SAAS,CAAC,CA4NxC"}

package/dist/memory/index.js

@@ -0,0 +1,573 @@
+/**
+ * `sbox-sdk/memory` — an in-memory sandbox provider. It is the zero-config
+ * default for `createSandboxClient()` and the fixture the conformance suite runs
+ * against. With `{ bareFs: true }` it hides the native filesystem methods so the
+ * core's exec-based polyfills (ls/mkdir/rm/mv/stat) are exercised instead.
+ */
+import { SandboxError } from "../adapter/index.js";
+const MEMORY_CAPS = {
+    background: "native",
+    codeInterpreter: "unsupported",
+    egressControl: "unsupported",
+    exposePort: "emulated",
+    filesUpload: "native",
+    filesWatch: "unsupported",
+    fork: "native",
+    gpu: "unsupported",
+    killProcess: "native",
+    list: "native",
+    metrics: "unsupported",
+    pause: "native",
+    privatePreview: "unsupported",
+    proxiedFetch: "unsupported",
+    pty: "unsupported",
+    region: "unsupported",
+    secretsVault: "unsupported",
+    setTimeout: "native",
+    snapshot: "native",
+    ssh: "unsupported",
+    statefulKernel: "unsupported",
+    stdin: "unsupported",
+    stop: "native",
+    streaming: "native",
+    volumes: "unsupported",
+};
+const MEMORY_FLAGS = {
+    exitCodeNative: true,
+    perCommandEnvCwd: true,
+    preservesDiskOnStop: true,
+    preservesMemoryOnPause: true,
+    previewModel: "ip",
+};
+// --------------------------------------------------------------------------
+// path helpers
+// --------------------------------------------------------------------------
+function normalizePath(p) {
+    const abs = p.startsWith("/") ? p : `/${p}`;
+    const parts = [];
+    for (const seg of abs.split("/")) {
+        if (seg === "" || seg === ".") {
+            continue;
+        }
+        if (seg === "..") {
+            parts.pop();
+        }
+        else {
+            parts.push(seg);
+        }
+    }
+    return `/${parts.join("/")}`;
+}
+function parentOf(p) {
+    const n = normalizePath(p);
+    const i = n.lastIndexOf("/");
+    return i <= 0 ? "/" : n.slice(0, i);
+}
+function baseName(p) {
+    const n = normalizePath(p);
+    return n.slice(n.lastIndexOf("/") + 1);
+}
+function resolvePath(cwd, p) {
+    return p.startsWith("/") ? normalizePath(p) : normalizePath(`${cwd}/${p}`);
+}
+function ancestors(dir) {
+    const out = [];
+    let cur = normalizePath(dir);
+    while (cur !== "/") {
+        out.unshift(cur);
+        cur = parentOf(cur);
+    }
+    return out;
+}
+// --------------------------------------------------------------------------
+// pure fs ops shared by native methods + exec interpreter
+// --------------------------------------------------------------------------
+function fsWrite(sb, path, data) {
+    const p = normalizePath(path);
+    for (const a of ancestors(parentOf(p))) {
+        sb.dirs.add(a);
+    }
+    sb.files.set(p, data);
+}
+function fsRead(sb, path) {
+    return sb.files.get(normalizePath(path)) ?? null;
+}
+function fsList(sb, dir) {
+    const d = normalizePath(dir);
+    if (!sb.dirs.has(d)) {
+        return null;
+    }
+    const seen = new Map();
+    for (const sub of sb.dirs) {
+        if (sub !== d && parentOf(sub) === d) {
+            const name = baseName(sub);
+            seen.set(name, { name, path: sub, type: "dir" });
+        }
+    }
+    for (const f of sb.files.keys()) {
+        if (parentOf(f) === d) {
+            const name = baseName(f);
+            seen.set(name, { name, path: f, type: "file" });
+        }
+    }
+    return [...seen.values()].toSorted((a, b) => a.name.localeCompare(b.name));
+}
+function fsMkdir(sb, path, recursive) {
+    const p = normalizePath(path);
+    if (sb.dirs.has(p)) {
+        return recursive ? null : `mkdir: cannot create '${path}': File exists`;
+    }
+    if (sb.files.has(p)) {
+        return `mkdir: cannot create '${path}': File exists`;
+    }
+    if (!recursive && !sb.dirs.has(parentOf(p))) {
+        return `mkdir: cannot create '${path}': No such file or directory`;
+    }
+    for (const a of ancestors(p)) {
+        sb.dirs.add(a);
+    }
+    return null;
+}
+function fsRemove(sb, path, recursive, force) {
+    const p = normalizePath(path);
+    if (sb.files.has(p)) {
+        sb.files.delete(p);
+        return null;
+    }
+    if (sb.dirs.has(p)) {
+        if (!recursive) {
+            return `rm: cannot remove '${path}': Is a directory`;
+        }
+        sb.dirs.delete(p);
+        for (const d of [...sb.dirs]) {
+            if (d.startsWith(`${p}/`)) {
+                sb.dirs.delete(d);
+            }
+        }
+        for (const f of [...sb.files.keys()]) {
+            if (f.startsWith(`${p}/`)) {
+                sb.files.delete(f);
+            }
+        }
+        return null;
+    }
+    return force
+        ? null
+        : `rm: cannot remove '${path}': No such file or directory`;
+}
+function fsRename(sb, from, to) {
+    const a = normalizePath(from);
+    const b = normalizePath(to);
+    if (sb.files.has(a)) {
+        fsWrite(sb, b, sb.files.get(a));
+        sb.files.delete(a);
+        return null;
+    }
+    if (sb.dirs.has(a)) {
+        for (const a2 of ancestors(b)) {
+            sb.dirs.add(a2);
+        }
+        sb.dirs.add(b);
+        for (const f of [...sb.files.keys()]) {
+            if (f === a || f.startsWith(`${a}/`)) {
+                fsWrite(sb, b + f.slice(a.length), sb.files.get(f));
+                sb.files.delete(f);
+            }
+        }
+        sb.dirs.delete(a);
+        return null;
+    }
+    return `mv: cannot stat '${from}': No such file or directory`;
+}
+function fsStat(sb, path) {
+    const p = normalizePath(path);
+    if (sb.dirs.has(p)) {
+        return { path: p, size: 0, type: "dir" };
+    }
+    const f = sb.files.get(p);
+    if (f) {
+        return { path: p, size: f.length, type: "file" };
+    }
+    return null;
+}
+function tokenize(input) {
+    const tokens = [];
+    let cur = "";
+    let quote = null;
+    let has = false;
+    for (const ch of input) {
+        if (quote) {
+            if (ch === quote) {
+                quote = null;
+            }
+            else {
+                cur += ch;
+            }
+            has = true;
+        }
+        else if (ch === "'" || ch === '"') {
+            quote = ch;
+            has = true;
+        }
+        else if (ch === " " || ch === "\t") {
+            if (has) {
+                tokens.push(cur);
+                cur = "";
+                has = false;
+            }
+        }
+        else {
+            cur += ch;
+            has = true;
+        }
+    }
+    if (has) {
+        tokens.push(cur);
+    }
+    return tokens;
+}
+function expandVars(s, env) {
+    return s.replaceAll(/\$\{(\w+)\}|\$(\w+)/g, (_m, a, b) => env[a ?? b] ?? "");
+}
+function runMemCommand(sb, command, opts) {
+    const cwd = opts.cwd ?? "/";
+    const env = { ...sb.env, ...opts.env };
+    const argv = tokenize(expandVars(command, env));
+    const [cmd] = argv;
+    const ok = (stdout = "") => ({ exit: 0, stderr: "", stdout });
+    const operands = argv.slice(1).filter((a) => !a.startsWith("-"));
+    switch (cmd) {
+        case undefined: {
+            return ok();
+        }
+        case "true": {
+            return ok();
+        }
+        case "false": {
+            return { exit: 1, stderr: "", stdout: "" };
+        }
+        case "exit": {
+            return { exit: Number(argv[1] ?? 0) || 0, stderr: "", stdout: "" };
+        }
+        case "pwd": {
+            return ok(`${cwd}\n`);
+        }
+        case "echo": {
+            let args = argv.slice(1);
+            let nl = true;
+            if (args[0] === "-n") {
+                nl = false;
+                args = args.slice(1);
+            }
+            return ok(args.join(" ") + (nl ? "\n" : ""));
+        }
+        case "printf": {
+            return ok((operands[0] ?? "").replaceAll(/\\n/g, "\n").replaceAll(/\\t/g, "\t"));
+        }
+        case "env": {
+            return ok(`${Object.entries(env)
+                .map(([k, v]) => `${k}=${v}`)
+                .join("\n")}\n`);
+        }
+        case "cat": {
+            let out = "";
+            for (const f of operands) {
+                const data = fsRead(sb, resolvePath(cwd, f));
+                if (!data) {
+                    return {
+                        exit: 1,
+                        stderr: `cat: ${f}: No such file or directory\n`,
+                        stdout: "",
+                    };
+                }
+                out += new TextDecoder().decode(data);
+            }
+            return ok(out);
+        }
+        case "touch": {
+            for (const f of operands) {
+                fsWrite(sb, resolvePath(cwd, f), new Uint8Array());
+            }
+            return ok();
+        }
+        case "ls": {
+            const entries = fsList(sb, resolvePath(cwd, operands[0] ?? "."));
+            if (!entries) {
+                return {
+                    exit: 2,
+                    stderr: `ls: cannot access '${operands[0] ?? "."}': No such file or directory\n`,
+                    stdout: "",
+                };
+            }
+            const names = entries.map((e) => e.type === "dir" ? `${e.name}/` : e.name);
+            return ok(names.length ? `${names.join("\n")}\n` : "");
+        }
+        case "mkdir": {
+            const recursive = argv.includes("-p");
+            const err = fsMkdir(sb, resolvePath(cwd, operands[0] ?? ""), recursive);
+            return err ? { exit: 1, stderr: `${err}\n`, stdout: "" } : ok();
+        }
+        case "rm": {
+            const flags = argv.filter((a) => a.startsWith("-")).join("");
+            const recursive = flags.includes("r") || flags.includes("R");
+            const force = flags.includes("f");
+            for (const f of operands) {
+                const err = fsRemove(sb, resolvePath(cwd, f), recursive, force);
+                if (err) {
+                    return { exit: 1, stderr: `${err}\n`, stdout: "" };
+                }
+            }
+            return ok();
+        }
+        case "mv": {
+            if (operands.length < 2) {
+                return { exit: 1, stderr: "mv: missing operand\n", stdout: "" };
+            }
+            const err = fsRename(sb, resolvePath(cwd, operands[0]), resolvePath(cwd, operands[1]));
+            return err ? { exit: 1, stderr: `${err}\n`, stdout: "" } : ok();
+        }
+        case "stat": {
+            const target = argv.at(-1) ?? "";
+            const info = fsStat(sb, resolvePath(cwd, target));
+            if (!info) {
+                return {
+                    exit: 1,
+                    stderr: `stat: cannot statx '${target}': No such file or directory\n`,
+                    stdout: "",
+                };
+            }
+            const kind = info.type === "dir" ? "directory" : "regular file";
+            return ok(`${kind}|${info.size}|0\n`);
+        }
+        default: {
+            return { exit: 127, stderr: `sh: ${cmd}: not found\n`, stdout: "" };
+        }
+    }
+}
+function toDriverExec(pid, r) {
+    return {
+        pid: Promise.resolve(pid),
+        async kill() {
+            /* nothing to kill in memory */
+        },
+        async *[Symbol.asyncIterator]() {
+            if (r.stdout) {
+                yield { data: r.stdout, type: "stdout" };
+            }
+            if (r.stderr) {
+                yield { data: r.stderr, type: "stderr" };
+            }
+            yield { exitCode: r.exit, type: "exit" };
+        },
+    };
+}
+// --------------------------------------------------------------------------
+// provider
+// --------------------------------------------------------------------------
+export function memory(opts = {}) {
+    {
+        const o = opts;
+        const bareFs = o.bareFs ?? false;
+        const sandboxes = new Map();
+        let counter = 0;
+        const spawnSandbox = (spec) => {
+            const id = `${o.idPrefix ?? "mem"}_${++counter}`;
+            const sb = {
+                createdAt: new Date(),
+                dirs: new Set(["/", "/tmp", "/home", "/app"]),
+                env: { ...spec.env },
+                files: new Map(),
+                id,
+                metadata: { ...spec.metadata },
+                ports: new Map(),
+                procCounter: 0,
+                processes: new Map(),
+                snapCounter: 0,
+                snapshots: new Map(),
+                state: "running",
+            };
+            sandboxes.set(id, sb);
+            return sb;
+        };
+        const info = (sb) => ({
+            createdAt: sb.createdAt,
+            id: sb.id,
+            metadata: sb.metadata,
+            provider: "memory",
+            raw: sb,
+            state: sb.state,
+        });
+        const makeHandle = (sb) => {
+            const required = {
+                connectProcess: (processId) => ({
+                    ...toDriverExec(processId, { exit: 0, stderr: "", stdout: "" }),
+                    id: processId,
+                }),
+                deleteSnapshot: (ref) => {
+                    sb.snapshots.delete(ref);
+                },
+                destroy: () => {
+                    sb.state = "destroyed";
+                    sandboxes.delete(sb.id);
+                },
+                exec: (cmd, execOpts) => toDriverExec(`p${++sb.procCounter}`, runMemCommand(sb, cmd, execOpts)),
+                exposePort: (port) => {
+                    const preview = { port, url: `http://127.0.0.1:${port}` };
+                    sb.ports.set(port, preview);
+                    return preview;
+                },
+                fork: (count) => {
+                    const out = [];
+                    for (let i = 0; i < count; i++) {
+                        const clone = spawnSandbox({ env: sb.env, metadata: sb.metadata });
+                        clone.files = new Map(sb.files);
+                        clone.dirs = new Set(sb.dirs);
+                        out.push(makeHandle(clone));
+                    }
+                    return out;
+                },
+                getInfo: () => info(sb),
+                id: sb.id,
+                killProcess: (processId) => {
+                    sb.processes.delete(processId);
+                },
+                listPorts: () => [...sb.ports.values()],
+                listProcesses: () => [...sb.processes.entries()].map(([id, p]) => ({ cmd: p.cmd, id })),
+                listSnapshots: () => [...sb.snapshots.keys()].map((id) => ({
+                    id,
+                    provider: "memory",
+                    raw: sb,
+                })),
+                pause: () => {
+                    sb.state = "paused";
+                },
+                raw: sb,
+                readFile: (path) => {
+                    const data = fsRead(sb, path);
+                    if (!data) {
+                        throw new SandboxError("NotFound", `no such file: '${path}'`, {
+                            provider: "memory",
+                        });
+                    }
+                    return data;
+                },
+                restoreSnapshot: (ref) => {
+                    const snap = sb.snapshots.get(ref);
+                    if (!snap) {
+                        throw new SandboxError("NotFound", `no snapshot ${ref}`, {
+                            provider: "memory",
+                        });
+                    }
+                    sb.files = new Map(snap.files);
+                    sb.dirs = new Set(snap.dirs);
+                },
+                resume: () => {
+                    sb.state = "running";
+                },
+                setTimeout: () => {
+                    /* memory sandboxes never expire */
+                },
+                snapshot: ({ name }) => {
+                    const id = `snap_${++sb.snapCounter}`;
+                    sb.snapshots.set(id, {
+                        dirs: new Set(sb.dirs),
+                        files: new Map(sb.files),
+                    });
+                    return {
+                        createdAt: new Date(),
+                        id,
+                        name,
+                        provider: "memory",
+                        raw: sb,
+                    };
+                },
+                spawn: (cmd, execOpts) => {
+                    const id = `p${++sb.procCounter}`;
+                    sb.processes.set(id, { cmd });
+                    return { ...toDriverExec(id, runMemCommand(sb, cmd, execOpts)), id };
+                },
+                stop: () => {
+                    sb.state = "stopped";
+                },
+                unexposePort: (port) => {
+                    sb.ports.delete(port);
+                },
+                writeFile: (path, data) => fsWrite(sb, path, data),
+            };
+            if (bareFs) {
+                return required;
+            }
+            return {
+                ...required,
+                listDir: (path) => {
+                    const entries = fsList(sb, path);
+                    if (!entries) {
+                        throw new SandboxError("NotFound", `not a directory: '${path}'`, {
+                            provider: "memory",
+                        });
+                    }
+                    return entries;
+                },
+                mkdir: (path, recursive) => {
+                    const err = fsMkdir(sb, path, recursive);
+                    if (err) {
+                        throw new SandboxError("Provider", err, { provider: "memory" });
+                    }
+                },
+                remove: (path, recursive) => {
+                    const err = fsRemove(sb, path, recursive, true);
+                    if (err) {
+                        throw new SandboxError("Provider", err, { provider: "memory" });
+                    }
+                },
+                rename: (from, to) => {
+                    const err = fsRename(sb, from, to);
+                    if (err) {
+                        throw new SandboxError("NotFound", err, { provider: "memory" });
+                    }
+                },
+                stat: (path) => {
+                    const i = fsStat(sb, path);
+                    if (!i) {
+                        throw new SandboxError("NotFound", `not found: '${path}'`, {
+                            provider: "memory",
+                        });
+                    }
+                    return i;
+                },
+                upload: (path, data) => {
+                    if (typeof data === "string") {
+                        fsWrite(sb, path, new TextEncoder().encode(data));
+                    }
+                    else if (data instanceof Uint8Array) {
+                        fsWrite(sb, path, data);
+                    }
+                    else {
+                        throw new SandboxError("Validation", "stream upload unsupported in memory");
+                    }
+                },
+            };
+        };
+        const provider = {
+            capabilities: MEMORY_CAPS,
+            connect: (id) => {
+                const sb = sandboxes.get(id);
+                if (!sb) {
+                    throw new SandboxError("NotFound", `no sandbox ${id}`, {
+                        provider: "memory",
+                    });
+                }
+                return makeHandle(sb);
+            },
+            create: (spec) => makeHandle(spawnSandbox(spec)),
+            flags: MEMORY_FLAGS,
+            async *list() {
+                for (const sb of sandboxes.values()) {
+                    yield info(sb);
+                }
+            },
+            name: "memory",
+        };
+        return provider;
+    }
+}

package/dist/modal/index.d.ts

@@ -0,0 +1,67 @@
+import type { Sandbox as ModalSandbox } from "modal";
+import type { SandboxProvider } from "../adapter/index.js";
+export interface ModalOptions {
+    tokenId?: string;
+    tokenSecret?: string;
+    environment?: string;
+    /** Modal App name to attach sandboxes to (created if missing). */
+    appName?: string;
+    /** Default container image when a sandbox spec doesn't set `template`. */
+    image?: string;
+}
+export declare const MODAL_CAPS: {
+    readonly background: "unsupported";
+    readonly codeInterpreter: "unsupported";
+    readonly egressControl: "unsupported";
+    readonly exposePort: "native";
+    readonly filesUpload: "native";
+    readonly filesWatch: "unsupported";
+    readonly fork: "unsupported";
+    readonly gpu: "native";
+    readonly killProcess: "unsupported";
+    readonly list: "native";
+    readonly metrics: "unsupported";
+    readonly pause: "unsupported";
+    readonly privatePreview: "unsupported";
+    readonly proxiedFetch: "unsupported";
+    readonly pty: "unsupported";
+    readonly region: "unsupported";
+    readonly secretsVault: "unsupported";
+    readonly setTimeout: "unsupported";
+    readonly snapshot: "unsupported";
+    readonly ssh: "unsupported";
+    readonly statefulKernel: "unsupported";
+    readonly stdin: "unsupported";
+    readonly stop: "unsupported";
+    readonly streaming: "native";
+    readonly volumes: "unsupported";
+};
+export type ModalCaps = typeof MODAL_CAPS;
+export declare const modal: (opts: ModalOptions) => SandboxProvider<{
+    readonly background: "unsupported";
+    readonly codeInterpreter: "unsupported";
+    readonly egressControl: "unsupported";
+    readonly exposePort: "native";
+    readonly filesUpload: "native";
+    readonly filesWatch: "unsupported";
+    readonly fork: "unsupported";
+    readonly gpu: "native";
+    readonly killProcess: "unsupported";
+    readonly list: "native";
+    readonly metrics: "unsupported";
+    readonly pause: "unsupported";
+    readonly privatePreview: "unsupported";
+    readonly proxiedFetch: "unsupported";
+    readonly pty: "unsupported";
+    readonly region: "unsupported";
+    readonly secretsVault: "unsupported";
+    readonly setTimeout: "unsupported";
+    readonly snapshot: "unsupported";
+    readonly ssh: "unsupported";
+    readonly statefulKernel: "unsupported";
+    readonly stdin: "unsupported";
+    readonly stop: "unsupported";
+    readonly streaming: "native";
+    readonly volumes: "unsupported";
+}, ModalSandbox>;
+//# sourceMappingURL=index.d.ts.map