sbox-sdk 0.0.2

package/dist/railway/index.js

@@ -0,0 +1,219 @@
+/**
+ * `sbox-sdk/railway` — adapter for Railway Sandboxes (the `railway` SDK). A
+ * "sandbox" is an ephemeral, isolated Debian Linux VM provisioned on demand.
+ * This is one of the richest adapters: exec streams natively via `onStdout`/
+ * `onStderr` callbacks (`streaming: native`) and returns a real exit code;
+ * filesystem is native and byte-accurate (`files.read(path, { format: "bytes" })`
+ * / `files.write`). `snapshot()` maps to `checkpoint()` and `fork()` to the
+ * native `fork()` (clone filesystem). Sandboxes are network-isolated, so there
+ * are no public preview ports. `destroy()` tears the VM down. Requires the
+ * optional peer dependency `railway`.
+ */
+import { AsyncQueue, defineProvider, SandboxError } from "../adapter/index.js";
+export const RAILWAY_CAPS = {
+    background: "unsupported",
+    codeInterpreter: "unsupported",
+    egressControl: "unsupported",
+    exposePort: "unsupported",
+    filesUpload: "native",
+    filesWatch: "unsupported",
+    fork: "native",
+    gpu: "unsupported",
+    killProcess: "unsupported",
+    list: "native",
+    metrics: "unsupported",
+    pause: "unsupported",
+    privatePreview: "unsupported",
+    proxiedFetch: "unsupported",
+    pty: "unsupported",
+    region: "unsupported",
+    secretsVault: "unsupported",
+    setTimeout: "unsupported",
+    snapshot: "native",
+    ssh: "unsupported",
+    statefulKernel: "unsupported",
+    stdin: "unsupported",
+    stop: "unsupported",
+    streaming: "native",
+    volumes: "unsupported",
+};
+const RAILWAY_FLAGS = {
+    exitCodeNative: true,
+    perCommandEnvCwd: true, // exec accepts { cwd, env }
+    preservesDiskOnStop: false,
+    preservesMemoryOnPause: false,
+    previewModel: "none", // sandboxes are network-isolated
+};
+let cached = null;
+async function loadRailway() {
+    if (!cached) {
+        cached = (await import("railway"));
+    }
+    return cached;
+}
+function sandboxId(sb) {
+    return sb.id ?? sb.sandboxId ?? "";
+}
+function mapState(state) {
+    switch ((state ?? "").toLowerCase()) {
+        case "running":
+        case "active": {
+            return "running";
+        }
+        case "idle":
+        case "stopped": {
+            return "stopped";
+        }
+        case "creating":
+        case "provisioning": {
+            return "creating";
+        }
+        case "destroyed": {
+            return "destroyed";
+        }
+        default: {
+            return "unknown";
+        }
+    }
+}
+function mapType(t, isDir) {
+    if (isDir || t === "dir" || t === "directory") {
+        return "dir";
+    }
+    if (t === "symlink") {
+        return "symlink";
+    }
+    return "file";
+}
+export const railway = defineProvider((opts) => {
+    const config = (extra = {}) => ({
+        token: opts.token,
+        environmentId: opts.environmentId,
+        ...extra,
+    });
+    const makeHandle = (sb) => {
+        const id = sandboxId(sb);
+        return {
+            id,
+            raw: sb,
+            getInfo() {
+                return {
+                    id,
+                    state: "running",
+                    provider: "railway",
+                    metadata: {},
+                    raw: sb,
+                };
+            },
+            async destroy() {
+                await sb.destroy();
+            },
+            exec(cmd, options) {
+                const queue = new AsyncQueue();
+                void sb
+                    .exec(cmd, {
+                    cwd: options.cwd,
+                    env: options.env,
+                    timeoutSec: options.timeoutMs
+                        ? Math.ceil(options.timeoutMs / 1000)
+                        : undefined,
+                    onStdout: (chunk) => queue.push({ type: "stdout", data: chunk }),
+                    onStderr: (chunk) => queue.push({ type: "stderr", data: chunk }),
+                })
+                    .then((r) => {
+                    queue.push({ type: "exit", exitCode: r.exitCode ?? 0 });
+                    queue.close();
+                })
+                    .catch((error) => queue.fail(error instanceof SandboxError
+                    ? error
+                    : SandboxError.wrap(error, "railway")));
+                return {
+                    pid: Promise.resolve(""),
+                    async kill() {
+                        /* streaming exec; kill handle not wired in v0.1 */
+                    },
+                    [Symbol.asyncIterator]: () => queue.iterator(),
+                };
+            },
+            async readFile(path) {
+                const data = await sb.files.read(path, { format: "bytes" });
+                return typeof data === "string"
+                    ? new TextEncoder().encode(data)
+                    : new Uint8Array(data);
+            },
+            async writeFile(path, data) {
+                await sb.files.write(path, data);
+            },
+            async listDir(path) {
+                const entries = await sb.files.list(path);
+                const base = path.replace(/\/$/, "");
+                return entries.map((e) => ({
+                    name: e.name,
+                    path: `${base}/${e.name}`,
+                    type: mapType(e.type, e.isDir),
+                }));
+            },
+            async mkdir(path) {
+                await sb.files.mkdir(path);
+            },
+            async remove(path) {
+                await sb.files.remove(path);
+            },
+            async rename(from, to) {
+                await sb.files.rename(from, to);
+            },
+            async stat(path) {
+                const s = await sb.files.stat(path);
+                return {
+                    path,
+                    type: mapType(s.type, s.isDir),
+                    size: s.size ?? 0,
+                    mtime: s.mtime ? new Date(s.mtime) : undefined,
+                };
+            },
+            async snapshot(snapOpts) {
+                const name = snapOpts.name ?? `snap-${globalThis.crypto.randomUUID().slice(0, 8)}`;
+                const cp = await sb.checkpoint(name);
+                const refId = typeof cp === "string" ? cp : (cp.id ?? cp.name ?? name);
+                return { id: refId, name, provider: "railway", raw: cp };
+            },
+            async fork(count) {
+                const forks = await Promise.all(Array.from({ length: count }, () => sb.fork()));
+                return forks.map((f) => makeHandle(f));
+            },
+        };
+    };
+    const provider = {
+        name: "railway",
+        capabilities: RAILWAY_CAPS,
+        flags: RAILWAY_FLAGS,
+        async create(spec) {
+            const mod = await loadRailway();
+            const sb = await mod.Sandbox.create(spec.template, config({
+                env: spec.env,
+                networkIsolation: opts.networkIsolation,
+                idleTimeoutMinutes: spec.ttlMs
+                    ? Math.ceil(spec.ttlMs / 60_000)
+                    : undefined,
+            }));
+            return makeHandle(sb);
+        },
+        async connect(id) {
+            const mod = await loadRailway();
+            return makeHandle(await mod.Sandbox.connect(id));
+        },
+        async *list() {
+            const mod = await loadRailway();
+            for (const s of await mod.Sandbox.list()) {
+                yield {
+                    id: s.id,
+                    state: mapState(s.status),
+                    provider: "railway",
+                    metadata: {},
+                    raw: s,
+                };
+            }
+        },
+    };
+    return provider;
+});

package/dist/runloop/index.d.ts

@@ -0,0 +1,69 @@
+import type { SandboxProvider } from "../adapter/index.js";
+export interface RunloopOptions {
+    apiKey?: string;
+    /** Override the API base URL (default uses the SDK default). */
+    baseURL?: string;
+    /** Default blueprint id used when `spec.template` is not provided. */
+    blueprintId?: string;
+}
+export declare const RUNLOOP_CAPS: {
+    readonly background: "unsupported";
+    readonly codeInterpreter: "unsupported";
+    readonly egressControl: "unsupported";
+    readonly exposePort: "native";
+    readonly filesUpload: "native";
+    readonly filesWatch: "unsupported";
+    readonly fork: "native";
+    readonly gpu: "unsupported";
+    readonly killProcess: "unsupported";
+    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: "unsupported";
+    readonly snapshot: "native";
+    readonly ssh: "unsupported";
+    readonly statefulKernel: "unsupported";
+    readonly stdin: "unsupported";
+    readonly stop: "unsupported";
+    readonly streaming: "emulated";
+    readonly volumes: "unsupported";
+};
+export type RunloopCaps = typeof RUNLOOP_CAPS;
+interface DevboxView {
+    id: string;
+    status?: string;
+}
+export declare const runloop: (opts: RunloopOptions) => SandboxProvider<{
+    readonly background: "unsupported";
+    readonly codeInterpreter: "unsupported";
+    readonly egressControl: "unsupported";
+    readonly exposePort: "native";
+    readonly filesUpload: "native";
+    readonly filesWatch: "unsupported";
+    readonly fork: "native";
+    readonly gpu: "unsupported";
+    readonly killProcess: "unsupported";
+    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: "unsupported";
+    readonly snapshot: "native";
+    readonly ssh: "unsupported";
+    readonly statefulKernel: "unsupported";
+    readonly stdin: "unsupported";
+    readonly stop: "unsupported";
+    readonly streaming: "emulated";
+    readonly volumes: "unsupported";
+}, DevboxView>;
+export {};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/runloop/index.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAQV,eAAe,EAIhB,MAAM,qBAAqB,CAAC;AAE7B,MAAM,WAAW,cAAc;IAC7B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,gEAAgE;IAChE,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,sEAAsE;IACtE,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;CA0BS,CAAC;AAEnC,MAAM,MAAM,WAAW,GAAG,OAAO,YAAY,CAAC;AAW9C,UAAU,UAAU;IAClB,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAwED,eAAO,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;cAgLnB,CAAC"}

package/dist/runloop/index.js

@@ -0,0 +1,226 @@
+/**
+ * `sbox-sdk/runloop` — adapter for the Runloop devbox API (`@runloop/api-client`).
+ * A "sandbox" is a Runloop devbox. exec is the buffered `devboxes.executeSync`
+ * (`{ stdout, stderr, exit_status }`); the devbox applies cwd/env via a shell, so
+ * the core folds them into a `cd … && KEY=v …` wrapper (`perCommandEnvCwd:
+ * false`). Files use the binary-safe `downloadFile`/`uploadFile` endpoints.
+ * Lifecycle: `suspend`/`resume` = pause (memory preserved), `shutdown` = destroy.
+ * Snapshots map to `snapshotDisk`; `fork()` snapshots then boots N devboxes from
+ * it (in-place restore is unsupported). Ports are tunnels (`enableTunnel`).
+ * Requires the optional peer dependency `@runloop/api-client`.
+ */
+import { AsyncQueue, defineProvider, SandboxError } from "../adapter/index.js";
+export const RUNLOOP_CAPS = {
+    background: "unsupported",
+    codeInterpreter: "unsupported",
+    egressControl: "unsupported",
+    exposePort: "native",
+    filesUpload: "native",
+    filesWatch: "unsupported",
+    fork: "native",
+    gpu: "unsupported",
+    killProcess: "unsupported",
+    list: "native",
+    metrics: "unsupported",
+    pause: "native",
+    privatePreview: "unsupported",
+    proxiedFetch: "unsupported",
+    pty: "unsupported",
+    region: "unsupported",
+    secretsVault: "unsupported",
+    setTimeout: "unsupported",
+    snapshot: "native",
+    ssh: "unsupported",
+    statefulKernel: "unsupported",
+    stdin: "unsupported",
+    stop: "unsupported",
+    streaming: "emulated",
+    volumes: "unsupported",
+};
+const RUNLOOP_FLAGS = {
+    exitCodeNative: true,
+    perCommandEnvCwd: false, // executeSync has no cwd/env — core wraps `cd && KEY=v`
+    preservesDiskOnStop: false,
+    preservesMemoryOnPause: true, // suspend preserves memory
+    previewModel: "subdomain",
+};
+let cached = null;
+async function loadRunloop() {
+    if (!cached) {
+        cached = (await import("@runloop/api-client"));
+    }
+    return cached;
+}
+function mapState(state) {
+    switch ((state ?? "").toLowerCase()) {
+        case "running": {
+            return "running";
+        }
+        case "suspended":
+        case "suspending": {
+            return "paused";
+        }
+        case "provisioning":
+        case "initializing": {
+            return "creating";
+        }
+        case "shutdown":
+        case "failure": {
+            return state === "failure" ? "error" : "destroyed";
+        }
+        default: {
+            return "unknown";
+        }
+    }
+}
+export const runloop = defineProvider((opts) => {
+    let clientP = null;
+    const getClient = () => {
+        if (!clientP) {
+            clientP = loadRunloop().then((mod) => new mod.default({
+                bearerToken: opts.apiKey,
+                baseURL: opts.baseURL,
+            }));
+        }
+        return clientP;
+    };
+    const makeHandle = (devbox, client) => {
+        const { id } = devbox;
+        return {
+            id,
+            raw: devbox,
+            getInfo() {
+                return {
+                    id,
+                    state: mapState(devbox.status),
+                    provider: "runloop",
+                    metadata: {},
+                    raw: devbox,
+                };
+            },
+            async destroy() {
+                await client.devboxes.shutdown(id);
+            },
+            async pause() {
+                await client.devboxes.suspend(id);
+            },
+            async resume() {
+                await client.devboxes.resume(id);
+            },
+            exec(cmd) {
+                const queue = new AsyncQueue();
+                void client.devboxes
+                    .executeSync(id, { command: cmd })
+                    .then((r) => {
+                    if (r.stdout) {
+                        queue.push({ type: "stdout", data: r.stdout });
+                    }
+                    if (r.stderr) {
+                        queue.push({ type: "stderr", data: r.stderr });
+                    }
+                    queue.push({ type: "exit", exitCode: r.exit_status ?? 0 });
+                    queue.close();
+                })
+                    .catch((error) => queue.fail(error instanceof SandboxError
+                    ? error
+                    : SandboxError.wrap(error, "runloop")));
+                return {
+                    pid: Promise.resolve(""),
+                    async kill() {
+                        /* executeSync is buffered; no kill handle */
+                    },
+                    [Symbol.asyncIterator]: () => queue.iterator(),
+                };
+            },
+            async readFile(path) {
+                const res = await client.devboxes.downloadFile(id, { path });
+                return new Uint8Array(await res.arrayBuffer());
+            },
+            async writeFile(path, data) {
+                await client.devboxes.uploadFile(id, { path, file: data });
+            },
+            async exposePort(port) {
+                const tunnel = await client.devboxes.enableTunnel(id, { port });
+                return { url: tunnel.url, port };
+            },
+            async unexposePort(port) {
+                await client.devboxes.removeTunnel(id, { port });
+            },
+            async snapshot(snapOpts) {
+                const snap = await client.devboxes.snapshotDisk(id, {
+                    name: snapOpts.name,
+                });
+                return {
+                    id: snap.id,
+                    name: snap.name ?? snapOpts.name,
+                    provider: "runloop",
+                    raw: snap,
+                };
+            },
+            async fork(count) {
+                // Runloop has no in-place fork: snapshot the disk, then boot N devboxes
+                // from that snapshot.
+                const snap = await client.devboxes.snapshotDisk(id, {});
+                const forks = await Promise.all(Array.from({ length: count }, () => client.devboxes.create({ snapshot_id: snap.id })));
+                return forks.map((d) => makeHandle(d, client));
+            },
+        };
+    };
+    const provider = {
+        name: "runloop",
+        capabilities: RUNLOOP_CAPS,
+        flags: RUNLOOP_FLAGS,
+        async create(spec) {
+            const client = await getClient();
+            const tpl = spec.template ?? opts.blueprintId;
+            const params = {
+                name: spec.name,
+                environment_variables: spec.env,
+            };
+            // A snapshot id restores disk state; otherwise treat the template as a
+            // blueprint id.
+            if (tpl) {
+                if (/^snp|snapshot/i.test(tpl)) {
+                    params.snapshot_id = tpl;
+                }
+                else {
+                    params.blueprint_id = tpl;
+                }
+            }
+            const devbox = await client.devboxes.create(params);
+            // Best-effort wait for the devbox to finish provisioning.
+            for (let i = 0; i < 30 && devbox.status !== "running"; i++) {
+                const got = await client.devboxes
+                    .retrieve(devbox.id)
+                    .catch(() => null);
+                if (!got) {
+                    break;
+                }
+                devbox.status = got.status;
+                if (got.status === "running" || got.status === "failure") {
+                    break;
+                }
+                await new Promise((r) => setTimeout(r, 1000));
+            }
+            return makeHandle(devbox, client);
+        },
+        async connect(id) {
+            const client = await getClient();
+            return makeHandle(await client.devboxes.retrieve(id), client);
+        },
+        async *list() {
+            const client = await getClient();
+            const page = await client.devboxes.list();
+            for (const d of page.devboxes ?? []) {
+                yield {
+                    id: d.id,
+                    state: mapState(d.status),
+                    provider: "runloop",
+                    metadata: {},
+                    raw: d,
+                };
+            }
+        },
+    };
+    return provider;
+});

package/dist/testing/index.d.ts

@@ -0,0 +1,44 @@
+/**
+ * `sbox-sdk/testing` — offline test doubles. `memory()` is a full in-memory
+ * provider; `failing()` always errors (to exercise retry/fallback paths).
+ */
+import { SandboxError } from "../adapter/index.js";
+import type { SandboxProvider } from "../adapter/index.js";
+export { memory } from "../memory/index.js";
+export type { MemoryOptions, MemoryCaps, MemoryRaw } from "../memory/index.js";
+declare const FAILING_CAPS: {
+    readonly background: "unsupported";
+    readonly codeInterpreter: "unsupported";
+    readonly egressControl: "unsupported";
+    readonly exposePort: "unsupported";
+    readonly filesUpload: "unsupported";
+    readonly filesWatch: "unsupported";
+    readonly fork: "unsupported";
+    readonly gpu: "unsupported";
+    readonly killProcess: "unsupported";
+    readonly list: "unsupported";
+    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: "unsupported";
+    readonly volumes: "unsupported";
+};
+export type FailingCaps = typeof FAILING_CAPS;
+export interface FailingOptions {
+    /** Error thrown on create()/connect(). Defaults to a retryable Provider error. */
+    error?: SandboxError;
+    name?: string;
+}
+/** A provider that always throws — useful for testing retry + fallback. */
+export declare function failing(opts?: FailingOptions): SandboxProvider<FailingCaps, never>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/testing/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,KAAK,EAGV,eAAe,EAChB,MAAM,qBAAqB,CAAC;AAE7B,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAC5C,YAAY,EAAE,aAAa,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAE/E,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;CA0BgB,CAAC;AAEnC,MAAM,MAAM,WAAW,GAAG,OAAO,YAAY,CAAC;AAU9C,MAAM,WAAW,cAAc;IAC7B,kFAAkF;IAClF,KAAK,CAAC,EAAE,YAAY,CAAC;IACrB,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,2EAA2E;AAC3E,wBAAgB,OAAO,CACrB,IAAI,GAAE,cAAmB,GACxB,eAAe,CAAC,WAAW,EAAE,KAAK,CAAC,CAoBrC"}

package/dist/testing/index.js

@@ -0,0 +1,61 @@
+/**
+ * `sbox-sdk/testing` — offline test doubles. `memory()` is a full in-memory
+ * provider; `failing()` always errors (to exercise retry/fallback paths).
+ */
+import { SandboxError } from "../adapter/index.js";
+export { memory } from "../memory/index.js";
+const FAILING_CAPS = {
+    background: "unsupported",
+    codeInterpreter: "unsupported",
+    egressControl: "unsupported",
+    exposePort: "unsupported",
+    filesUpload: "unsupported",
+    filesWatch: "unsupported",
+    fork: "unsupported",
+    gpu: "unsupported",
+    killProcess: "unsupported",
+    list: "unsupported",
+    metrics: "unsupported",
+    pause: "unsupported",
+    privatePreview: "unsupported",
+    proxiedFetch: "unsupported",
+    pty: "unsupported",
+    region: "unsupported",
+    secretsVault: "unsupported",
+    setTimeout: "unsupported",
+    snapshot: "unsupported",
+    ssh: "unsupported",
+    statefulKernel: "unsupported",
+    stdin: "unsupported",
+    stop: "unsupported",
+    streaming: "unsupported",
+    volumes: "unsupported",
+};
+const FAILING_FLAGS = {
+    exitCodeNative: true,
+    perCommandEnvCwd: true,
+    preservesDiskOnStop: false,
+    preservesMemoryOnPause: false,
+    previewModel: "none",
+};
+/** A provider that always throws — useful for testing retry + fallback. */
+export function failing(opts = {}) {
+    const o = opts;
+    const err = () => o.error ??
+        new SandboxError("Provider", "failing provider always fails", {
+            provider: o.name ?? "failing",
+            retryable: true,
+        });
+    const provider = {
+        capabilities: FAILING_CAPS,
+        connect() {
+            throw err();
+        },
+        create() {
+            throw err();
+        },
+        flags: FAILING_FLAGS,
+        name: o.name ?? "failing",
+    };
+    return provider;
+}

package/dist/vercel/index.d.ts

@@ -0,0 +1,63 @@
+import type { Sandbox as VercelSandbox } from "@vercel/sandbox";
+import type { SandboxProvider } from "../adapter/index.js";
+export interface VercelOptions {
+    token: string;
+    teamId: string;
+    projectId: string;
+}
+export declare const VERCEL_CAPS: {
+    readonly background: "native";
+    readonly codeInterpreter: "unsupported";
+    readonly egressControl: "unsupported";
+    readonly exposePort: "native";
+    readonly filesUpload: "native";
+    readonly filesWatch: "unsupported";
+    readonly fork: "unsupported";
+    readonly gpu: "unsupported";
+    readonly killProcess: "unsupported";
+    readonly list: "unsupported";
+    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 VercelCaps = typeof VERCEL_CAPS;
+export declare const vercel: (opts: VercelOptions) => SandboxProvider<{
+    readonly background: "native";
+    readonly codeInterpreter: "unsupported";
+    readonly egressControl: "unsupported";
+    readonly exposePort: "native";
+    readonly filesUpload: "native";
+    readonly filesWatch: "unsupported";
+    readonly fork: "unsupported";
+    readonly gpu: "unsupported";
+    readonly killProcess: "unsupported";
+    readonly list: "unsupported";
+    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";
+}, VercelSandbox>;
+//# sourceMappingURL=index.d.ts.map