sbox-sdk 0.0.2

package/dist/cli.js

@@ -0,0 +1,249 @@
+#!/usr/bin/env node
+/**
+ * `sbox` CLI — diagnostics + a one-shot runner for the unified sandbox SDK.
+ *
+ * Every command lazy-imports only the provider it touches (and the vendor SDK
+ * only when a sandbox is actually created), so the published `bin` never bundles
+ * all provider SDKs. `caps` and `doctor` are fully offline; `exec` and `list`
+ * talk to the real provider using credentials from the environment.
+ */
+import { createRequire } from "node:module";
+/** Registry of the network-backed adapters the CLI can drive by id. */
+const PROVIDERS = {
+    e2b: { caps: "E2B_CAPS", factory: "e2b", pkg: "@e2b/code-interpreter" },
+    vercel: { caps: "VERCEL_CAPS", factory: "vercel", pkg: "@vercel/sandbox" },
+    cloudflare: {
+        caps: "CLOUDFLARE_CAPS",
+        factory: "cloudflare",
+        pkg: "@cloudflare/sandbox",
+    },
+    daytona: { caps: "DAYTONA_CAPS", factory: "daytona", pkg: "@daytonaio/sdk" },
+    modal: { caps: "MODAL_CAPS", factory: "modal", pkg: "modal" },
+    fly: { caps: "FLY_CAPS", factory: "fly", pkg: null },
+    "aws-lambda": {
+        caps: "AWS_LAMBDA_CAPS",
+        factory: "awsLambda",
+        pkg: "@aws-sdk/client-lambda-microvms",
+    },
+    northflank: {
+        caps: "NORTHFLANK_CAPS",
+        factory: "northflank",
+        pkg: "@northflank/js-client",
+    },
+    runloop: {
+        caps: "RUNLOOP_CAPS",
+        factory: "runloop",
+        pkg: "@runloop/api-client",
+    },
+    codesandbox: {
+        caps: "CODESANDBOX_CAPS",
+        factory: "codesandbox",
+        pkg: "@codesandbox/sdk",
+    },
+    morph: { caps: "MORPH_CAPS", factory: "morph", pkg: "morphcloud" },
+    blaxel: { caps: "BLAXEL_CAPS", factory: "blaxel", pkg: "@blaxel/core" },
+    beam: { caps: "BEAM_CAPS", factory: "beam", pkg: "@beamcloud/beam-js" },
+    railway: { caps: "RAILWAY_CAPS", factory: "railway", pkg: "railway" },
+};
+const LEVEL_SYMBOL = {
+    emulated: "◐",
+    native: "●",
+    unsupported: "○",
+};
+function write(s) {
+    process.stdout.write(`${s}\n`);
+}
+function writeErr(s) {
+    process.stderr.write(`${s}\n`);
+}
+function unknownProvider(id) {
+    writeErr(`sbox: unknown provider '${id}'. Known: ${Object.keys(PROVIDERS).join(", ")}`);
+    return 1;
+}
+/** Import a built adapter module by id (cheap — vendor SDK stays lazy). */
+async function importProvider(id) {
+    return (await import(`./${id}/index.js`));
+}
+function printHelp() {
+    write([
+        "sbox — one unified CLI for agent sandbox providers",
+        "",
+        "Usage:",
+        "  sbox caps <provider>            print a provider's capability matrix",
+        "  sbox doctor [<provider>]        validate node + provider SDK setup",
+        "  sbox exec <provider> -- <cmd>   run one command in a fresh sandbox",
+        "  sbox list <provider>            list a provider's live sandboxes",
+        "",
+        `Providers: ${Object.keys(PROVIDERS).join(", ")}`,
+        "",
+        "Credentials for exec/list are read from the environment (see each",
+        "provider's docs). caps and doctor run fully offline.",
+    ].join("\n"));
+}
+async function cmdCaps(id) {
+    if (!id) {
+        writeErr("sbox: caps needs a provider, e.g. `sbox caps e2b`");
+        return 1;
+    }
+    const meta = PROVIDERS[id];
+    if (!meta) {
+        return unknownProvider(id);
+    }
+    const mod = await importProvider(id);
+    const map = mod[meta.caps];
+    if (!map) {
+        writeErr(`sbox: '${id}' does not export ${meta.caps}`);
+        return 1;
+    }
+    const names = Object.keys(map).toSorted();
+    const width = Math.max(...names.map((n) => n.length));
+    const counts = {
+        emulated: 0,
+        native: 0,
+        unsupported: 0,
+    };
+    write(`${id} capabilities\n`);
+    for (const name of names) {
+        const level = map[name];
+        if (!level) {
+            continue;
+        }
+        counts[level]++;
+        write(`  ${LEVEL_SYMBOL[level]} ${name.padEnd(width)}  ${level}`);
+    }
+    write(`\n  ${counts.native} native · ${counts.emulated} emulated · ${counts.unsupported} unsupported`);
+    return 0;
+}
+async function cmdDoctor(id) {
+    let ok = true;
+    write("sbox doctor\n");
+    const major = Number(process.versions.node.split(".")[0]);
+    const nodeOk = major >= 20;
+    ok &&= nodeOk;
+    write(`  ${nodeOk ? "✔" : "✖"} node ${process.versions.node}${nodeOk ? "" : " (requires >= 20)"}`);
+    if (id) {
+        const meta = PROVIDERS[id];
+        if (!meta) {
+            return unknownProvider(id);
+        }
+        if (meta.pkg) {
+            const req = createRequire(import.meta.url);
+            let installed = true;
+            try {
+                req.resolve(meta.pkg);
+            }
+            catch {
+                installed = false;
+            }
+            ok &&= installed;
+            write(installed
+                ? `  ✔ provider SDK '${meta.pkg}' is installed`
+                : `  ✖ provider SDK '${meta.pkg}' is missing — run: npm install ${meta.pkg}`);
+        }
+        else {
+            write(`  ✔ ${id} needs no extra SDK (uses the platform REST API)`);
+        }
+    }
+    write(`\n  ${ok ? "all checks passed" : "some checks failed"}`);
+    return ok ? 0 : 1;
+}
+async function withProvider(id, fn) {
+    const meta = PROVIDERS[id];
+    if (!meta) {
+        return unknownProvider(id);
+    }
+    const mod = await importProvider(id);
+    const factory = mod[meta.factory];
+    if (!factory) {
+        writeErr(`sbox: '${id}' does not export ${meta.factory}`);
+        return 1;
+    }
+    return await fn(factory({}));
+}
+async function cmdExec(id, command) {
+    if (!(id && command)) {
+        writeErr("sbox: usage: sbox exec <provider> -- <cmd>");
+        return 1;
+    }
+    const { createSandboxClient } = await import("./index.js");
+    return await withProvider(id, async (provider) => {
+        const client = createSandboxClient({ provider });
+        try {
+            const sandbox = await client.create();
+            try {
+                const res = await sandbox.commands.run(command);
+                if (res.stdout) {
+                    process.stdout.write(res.stdout);
+                }
+                if (res.stderr) {
+                    process.stderr.write(res.stderr);
+                }
+                return res.exitCode ?? 0;
+            }
+            finally {
+                await sandbox.destroy();
+            }
+        }
+        finally {
+            await client.dispose();
+        }
+    });
+}
+async function cmdList(id) {
+    if (!id) {
+        writeErr("sbox: list needs a provider, e.g. `sbox list e2b`");
+        return 1;
+    }
+    const { createSandboxClient } = await import("./index.js");
+    return await withProvider(id, async (provider) => {
+        const client = createSandboxClient({ provider });
+        try {
+            let n = 0;
+            for await (const info of client.list()) {
+                n++;
+                const state = info.state ? ` [${info.state}]` : "";
+                write(`${info.id}${state}`);
+            }
+            if (n === 0) {
+                write("(no sandboxes)");
+            }
+            return 0;
+        }
+        finally {
+            await client.dispose();
+        }
+    });
+}
+async function main(argv) {
+    const [cmd, ...rest] = argv;
+    if (!cmd || cmd === "help" || cmd === "--help" || cmd === "-h") {
+        printHelp();
+        return 0;
+    }
+    switch (cmd) {
+        case "caps":
+            return await cmdCaps(rest[0]);
+        case "doctor": {
+            const flag = rest.indexOf("--provider");
+            const id = flag === -1 ? rest[0] : rest[flag + 1];
+            return await cmdDoctor(id);
+        }
+        case "exec": {
+            const sep = rest.indexOf("--");
+            const command = (sep === -1 ? rest.slice(1) : rest.slice(sep + 1)).join(" ");
+            return await cmdExec(rest[0], command);
+        }
+        case "list":
+            return await cmdList(rest[0]);
+        default:
+            writeErr(`sbox: unknown command '${cmd}'. Try \`sbox help\`.`);
+            return 1;
+    }
+}
+main(process.argv.slice(2))
+    .then((code) => process.exit(code))
+    .catch((err) => {
+    const message = err instanceof Error ? err.message : String(err);
+    writeErr(`sbox: ${message}`);
+    process.exit(1);
+});

package/dist/cloudflare/index.d.ts

@@ -0,0 +1,64 @@
+import type { Sandbox as CFSandbox } from "@cloudflare/sandbox";
+import type { SandboxProvider } from "../adapter/index.js";
+export interface CloudflareOptions {
+    /** The Durable Object namespace binding for your exported Sandbox class. */
+    binding: unknown;
+    /** Your Worker's domain — required to build preview URLs for exposed ports. */
+    hostname?: string;
+}
+export declare const CLOUDFLARE_CAPS: {
+    readonly background: "unsupported";
+    readonly codeInterpreter: "native";
+    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: "native";
+    readonly pty: "unsupported";
+    readonly region: "unsupported";
+    readonly secretsVault: "unsupported";
+    readonly setTimeout: "native";
+    readonly snapshot: "unsupported";
+    readonly ssh: "unsupported";
+    readonly statefulKernel: "native";
+    readonly stdin: "unsupported";
+    readonly stop: "unsupported";
+    readonly streaming: "native";
+    readonly volumes: "unsupported";
+};
+export type CloudflareCaps = typeof CLOUDFLARE_CAPS;
+export declare const cloudflare: (opts: CloudflareOptions) => SandboxProvider<{
+    readonly background: "unsupported";
+    readonly codeInterpreter: "native";
+    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: "native";
+    readonly pty: "unsupported";
+    readonly region: "unsupported";
+    readonly secretsVault: "unsupported";
+    readonly setTimeout: "native";
+    readonly snapshot: "unsupported";
+    readonly ssh: "unsupported";
+    readonly statefulKernel: "native";
+    readonly stdin: "unsupported";
+    readonly stop: "unsupported";
+    readonly streaming: "native";
+    readonly volumes: "unsupported";
+}, CFSandbox<unknown>>;
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/cloudflare/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,qBAAqB,CAAC;AAwBhE,OAAO,KAAK,EAaV,eAAe,EAEhB,MAAM,qBAAqB,CAAC;AAE7B,MAAM,WAAW,iBAAiB;IAChC,4EAA4E;IAC5E,OAAO,EAAE,OAAO,CAAC;IACjB,+EAA+E;IAC/E,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;CA0BM,CAAC;AAEnC,MAAM,MAAM,cAAc,GAAG,OAAO,eAAe,CAAC;AAwEpD,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;sBAoPrB,CAAC"}

package/dist/cloudflare/index.js

@@ -0,0 +1,259 @@
+/**
+ * `sbox-sdk/cloudflare` — adapter for `@cloudflare/sandbox`. Unlike API-key
+ * providers, Cloudflare sandboxes run INSIDE a Cloudflare Worker against a
+ * Durable Object / Container binding. So the factory takes the binding, and
+ * `create()` is get-or-create (no imperative create; ids are names). This is the
+ * edge-portability stress test: the core stays fetch-only, no `node:` imports.
+ *
+ * Usage (inside a Worker):
+ * ```ts
+ * import { createSandboxClient } from "sbox-sdk";
+ * import { cloudflare } from "sbox-sdk/cloudflare";
+ * const client = createSandboxClient({ provider: cloudflare({ binding: env.Sandbox, hostname: "example.com" }) });
+ * ```
+ * Requires the optional peer dependency `@cloudflare/sandbox`, and you must
+ * `export { Sandbox } from "@cloudflare/sandbox"` from your Worker entry.
+ */
+import { AsyncQueue, defineProvider, NotSupportedError, SandboxError, } from "../adapter/index.js";
+export const CLOUDFLARE_CAPS = {
+    background: "unsupported",
+    codeInterpreter: "native",
+    egressControl: "unsupported",
+    exposePort: "native",
+    filesUpload: "native",
+    filesWatch: "unsupported",
+    fork: "unsupported",
+    gpu: "unsupported",
+    killProcess: "unsupported",
+    list: "unsupported",
+    metrics: "unsupported",
+    pause: "unsupported",
+    privatePreview: "unsupported",
+    proxiedFetch: "native",
+    pty: "unsupported",
+    region: "unsupported",
+    secretsVault: "unsupported",
+    setTimeout: "native",
+    snapshot: "unsupported",
+    ssh: "unsupported",
+    statefulKernel: "native",
+    stdin: "unsupported",
+    stop: "unsupported",
+    streaming: "native",
+    volumes: "unsupported",
+};
+const CLOUDFLARE_FLAGS = {
+    exitCodeNative: true,
+    perCommandEnvCwd: true,
+    preservesDiskOnStop: false,
+    preservesMemoryOnPause: false,
+    previewModel: "wildcardDNS",
+};
+let cached = null;
+async function loadCF() {
+    if (!cached) {
+        cached = (await import("@cloudflare/sandbox"));
+    }
+    return cached;
+}
+function base64ToBytes(b64) {
+    const bin = atob(b64);
+    const out = new Uint8Array(bin.length);
+    for (let i = 0; i < bin.length; i++) {
+        out[i] = bin.codePointAt(i) ?? 0;
+    }
+    return out;
+}
+function mapResult(r) {
+    const rr = r;
+    const mime = {};
+    const put = (key, mt) => {
+        const v = rr[key];
+        if (typeof v === "string") {
+            mime[mt] = v;
+        }
+    };
+    put("text", "text/plain");
+    put("html", "text/html");
+    put("png", "image/png");
+    put("jpeg", "image/jpeg");
+    put("svg", "image/svg+xml");
+    put("markdown", "text/markdown");
+    return { mime, text: typeof rr.text === "string" ? rr.text : undefined };
+}
+function mapCFError(e) {
+    const msg = e instanceof Error ? e.message : String(e);
+    if (/not ?found/i.test(msg)) {
+        return new SandboxError("NotFound", msg, {
+            cause: e,
+            provider: "cloudflare",
+        });
+    }
+    if (/unauthor|forbidden/i.test(msg)) {
+        return new SandboxError("Unauthorized", msg, {
+            cause: e,
+            provider: "cloudflare",
+        });
+    }
+    if (/timeout|timed out/i.test(msg)) {
+        return new SandboxError("Timeout", msg, {
+            cause: e,
+            provider: "cloudflare",
+        });
+    }
+    return undefined;
+}
+export const cloudflare = defineProvider((opts) => {
+    const getStub = async (id) => {
+        const mod = await loadCF();
+        const getSandbox = mod.getSandbox;
+        return getSandbox(opts.binding, id);
+    };
+    const makeHandle = (stub, id, defaultEnv) => {
+        const s = stub;
+        const contexts = new Map();
+        return {
+            async createContext(options) {
+                const c = await s.createCodeContext({ language: options.language });
+                contexts.set(c.id, c);
+                return { id: c.id, language: options.language ?? "python" };
+            },
+            async destroy() {
+                await s.destroy();
+            },
+            exec(cmd, options) {
+                const queue = new AsyncQueue();
+                void s
+                    .exec(cmd, {
+                    cwd: options.cwd,
+                    env: { ...defaultEnv, ...options.env },
+                    onOutput: (stream, data) => queue.push({ type: stream, data }),
+                    stream: true,
+                    timeout: options.timeoutMs,
+                })
+                    .then((res) => {
+                    queue.push({ exitCode: res.exitCode, type: "exit" });
+                    queue.close();
+                })
+                    .catch((error) => queue.fail(mapCFError(error) ?? SandboxError.wrap(error, "cloudflare")));
+                return {
+                    pid: Promise.resolve(""),
+                    async kill() {
+                        /* buffered exec has no kill handle */
+                    },
+                    [Symbol.asyncIterator]: () => queue.iterator(),
+                };
+            },
+            exposePort(port) {
+                if (!opts.hostname) {
+                    throw new NotSupportedError("cloudflare", "ports.expose (set `hostname` in cloudflare({...}) options)");
+                }
+                return s
+                    .exposePort(port, { hostname: opts.hostname })
+                    .then((r) => ({ port: r.port, url: r.url }));
+            },
+            getInfo() {
+                return {
+                    id,
+                    metadata: {},
+                    provider: "cloudflare",
+                    raw: stub,
+                    state: "running",
+                };
+            },
+            id,
+            async listDir(path) {
+                const r = await s.listFiles(path);
+                return r.files.map((f) => ({
+                    name: f.name,
+                    path: f.path ?? `${path}/${f.name}`,
+                    type: f.isDirectory || f.type === "directory" || f.type === "dir"
+                        ? "dir"
+                        : "file",
+                }));
+            },
+            async listPorts() {
+                if (!opts.hostname) {
+                    return [];
+                }
+                const ports = await s.getExposedPorts(opts.hostname);
+                return ports.map((p) => ({ port: p.port, url: p.url }));
+            },
+            async mkdir(path, recursive) {
+                await s.mkdir(path, { recursive });
+            },
+            proxyFetch(port, path, init) {
+                const url = `http://localhost:${port}${path ?? "/"}`;
+                return s.containerFetch(url, init ?? {}, port);
+            },
+            raw: stub,
+            async readFile(path) {
+                const r = await s.readFile(path);
+                return r.encoding === "base64"
+                    ? base64ToBytes(r.content)
+                    : new TextEncoder().encode(r.content);
+            },
+            async remove(path) {
+                await s.deleteFile(path);
+            },
+            async rename(from, to) {
+                await s.renameFile(from, to);
+            },
+            async runCode(code, options) {
+                const realContext = options.context
+                    ? contexts.get(options.context.id)
+                    : undefined;
+                const exec = await s.runCode(code, {
+                    context: realContext,
+                    language: options.language,
+                });
+                return {
+                    error: exec.error
+                        ? {
+                            name: exec.error.name,
+                            value: exec.error.value,
+                            traceback: exec.error.traceback,
+                        }
+                        : undefined,
+                    logs: {
+                        stderr: exec.logs?.stderr ?? [],
+                        stdout: exec.logs?.stdout ?? [],
+                    },
+                    results: (exec.results ?? []).map(mapResult),
+                };
+            },
+            async setTimeout(ttlMs) {
+                await s.setSleepAfter(ttlMs);
+            },
+            async unexposePort(port) {
+                await s.unexposePort(port);
+            },
+            async writeFile(path, data) {
+                const stream = new ReadableStream({
+                    start(controller) {
+                        controller.enqueue(data);
+                        controller.close();
+                    },
+                });
+                await s.writeFile(path, stream);
+            },
+        };
+    };
+    const provider = {
+        name: "cloudflare",
+        capabilities: CLOUDFLARE_CAPS,
+        flags: CLOUDFLARE_FLAGS,
+        mapError: mapCFError,
+        async create(spec, ctx) {
+            // get-or-create: the id IS the name. Use idempotencyKey so retries hit
+            // the same Durable Object instead of orphaning a new one.
+            const id = spec.name ?? ctx.idempotencyKey ?? globalThis.crypto.randomUUID();
+            return makeHandle(await getStub(id), id, spec.env);
+        },
+        async connect(id) {
+            return makeHandle(await getStub(id), id);
+        },
+        // NOTE: no `list` — Durable Objects are not enumerable (caps.list = unsupported).
+    };
+    return provider;
+});

package/dist/codesandbox/index.d.ts

@@ -0,0 +1,100 @@
+import type { SandboxProvider } from "../adapter/index.js";
+export interface CodeSandboxOptions {
+    apiKey?: string;
+    /** Default template/sandbox id to fork from when `spec.template` is unset. */
+    templateId?: string;
+}
+export declare const CODESANDBOX_CAPS: {
+    readonly background: "unsupported";
+    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: "native";
+    readonly metrics: "unsupported";
+    readonly pause: "native";
+    readonly privatePreview: "native";
+    readonly proxiedFetch: "unsupported";
+    readonly pty: "unsupported";
+    readonly region: "unsupported";
+    readonly secretsVault: "unsupported";
+    readonly setTimeout: "native";
+    readonly snapshot: "unsupported";
+    readonly ssh: "unsupported";
+    readonly statefulKernel: "unsupported";
+    readonly stdin: "unsupported";
+    readonly stop: "unsupported";
+    readonly streaming: "emulated";
+    readonly volumes: "unsupported";
+};
+export type CodeSandboxCaps = typeof CODESANDBOX_CAPS;
+interface CsbFsEntry {
+    name: string;
+    type?: string;
+    isSymlink?: boolean;
+}
+interface CsbStat {
+    type?: string;
+    size?: number;
+    mtime?: number;
+}
+interface CsbClient {
+    commands: {
+        run(cmd: string, opts?: {
+            cwd?: string;
+            env?: Record<string, string>;
+        }): Promise<string>;
+    };
+    fs: {
+        readFile(path: string): Promise<Uint8Array>;
+        writeFile(path: string, data: Uint8Array, opts?: {
+            create?: boolean;
+            overwrite?: boolean;
+        }): Promise<void>;
+        readdir(path: string): Promise<CsbFsEntry[]>;
+        stat(path: string): Promise<CsbStat>;
+        rename(from: string, to: string): Promise<void>;
+        remove(path: string, recursive?: boolean): Promise<void>;
+    };
+    hosts: {
+        getUrl(port: number, protocol?: string): string;
+    };
+}
+interface CsbSandbox {
+    id: string;
+    connect(): Promise<CsbClient>;
+    updateHibernationTimeout(seconds: number): Promise<void>;
+}
+export declare const codesandbox: (opts: CodeSandboxOptions) => SandboxProvider<{
+    readonly background: "unsupported";
+    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: "native";
+    readonly metrics: "unsupported";
+    readonly pause: "native";
+    readonly privatePreview: "native";
+    readonly proxiedFetch: "unsupported";
+    readonly pty: "unsupported";
+    readonly region: "unsupported";
+    readonly secretsVault: "unsupported";
+    readonly setTimeout: "native";
+    readonly snapshot: "unsupported";
+    readonly ssh: "unsupported";
+    readonly statefulKernel: "unsupported";
+    readonly stdin: "unsupported";
+    readonly stop: "unsupported";
+    readonly streaming: "emulated";
+    readonly volumes: "unsupported";
+}, CsbSandbox>;
+export {};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/codesandbox/index.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAWV,eAAe,EAGhB,MAAM,qBAAqB,CAAC;AAE7B,MAAM,WAAW,kBAAkB;IACjC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,8EAA8E;IAC9E,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;CA0BK,CAAC;AAEnC,MAAM,MAAM,eAAe,GAAG,OAAO,gBAAgB,CAAC;AAetD,UAAU,UAAU;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB;AACD,UAAU,OAAO;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB;AACD,UAAU,SAAS;IACjB,QAAQ,EAAE;QACR,GAAG,CACD,GAAG,EAAE,MAAM,EACX,IAAI,CAAC,EAAE;YAAE,GAAG,CAAC,EAAE,MAAM,CAAC;YAAC,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;SAAE,GACpD,OAAO,CAAC,MAAM,CAAC,CAAC;KACpB,CAAC;IACF,EAAE,EAAE;QACF,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;QAC5C,SAAS,CACP,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,UAAU,EAChB,IAAI,CAAC,EAAE;YAAE,MAAM,CAAC,EAAE,OAAO,CAAC;YAAC,SAAS,CAAC,EAAE,OAAO,CAAA;SAAE,GAC/C,OAAO,CAAC,IAAI,CAAC,CAAC;QACjB,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC,CAAC;QAC7C,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;QACrC,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;QAChD,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;KAC1D,CAAC;IACF,KAAK,EAAE;QAAE,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,CAAC;CAC5D;AACD,UAAU,UAAU;IAClB,EAAE,EAAE,MAAM,CAAC;IACX,OAAO,IAAI,OAAO,CAAC,SAAS,CAAC,CAAC;IAC9B,wBAAwB,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1D;AAkDD,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;cAiKtB,CAAC"}