withruntime 0.11.2 → 0.12.0

package/dist/cloudflare/index.js

@@ -1,8 +1,16 @@
 import { createHash } from "node:crypto";
 import { Runtime } from "../client.js";
 import { NotFoundError } from "../errors.js";
-import { client, closeShell, CompatibilityError, destroy, environment, execOptions, only, pathAt, saveEnvironment, shellCommand, shellRoot, } from "../compat/core.js";
+import { timeoutSignal } from "../transport.js";
+import { quote, client, closeShell, CompatibilityError, refuse, destroy, environment, execOptions, only, pathAt, saveEnvironment, shellCommand, shellRoot, } from "../compat/core.js";
+import { BucketUnmountError, InvalidMountConfigError, ProcessExitedBeforeReadyError, ProcessReadyTimeoutError, S3FSMountError, response, } from "./errors.js";
+import { CodeInterpreter, hasEnv, RUN_ENV, } from "./interpreter.js";
+import { sseStream } from "./streams.js";
+import { CHANGES, watchFilters } from "./watch.js";
 export { CompatibilityError };
+export * from "./errors.js";
+export { CodeInterpreter } from "./interpreter.js";
+export { collectFile, isExecResult, isProcess, isProcessStatus, parseSSEStream, streamFile, } from "./streams.js";
 export class SandboxSecurityError extends Error {
     code;
     constructor(message, code) {
@@ -55,12 +63,33 @@ export class Sandbox {
     pending;
     existing;
     id;
+    /** The port Cloudflare's container serves on; Runtime previews any port. */
+    defaultPort = 3000;
+    /** What setEnvVars gave this handle; the sandbox keeps them for every command. */
+    envVars = {};
+    #interpreter = new CodeInterpreter(this);
     constructor(runtime, id, options = {}) {
         this.runtime = runtime;
         this.options = options;
         validateSandboxConfiguration(options);
         this.id = id;
     }
+    get sleepAfter() {
+        return this.options.sleepAfter ?? "10m";
+    }
+    setSleepAfter(sleepAfter) {
+        return this.configure({ sleepAfter });
+    }
+    setKeepAlive(keepAlive) {
+        return this.configure({ keepAlive });
+    }
+    /** Replaces the sandbox's labels, as Cloudflare's does. */
+    async setLabels(labels) {
+        for (const [key, value] of Object.entries(labels))
+            if (typeof value !== "string")
+                throw new TypeError(`Label ${key} must be a string`);
+        await (await this.native()).update({ labels: { ...labels, "compat.provider": "cloudflare" } });
+    }
     async configure(options) {
         only("Cloudflare configure", options, ["sleepAfter", "keepAlive"]);
         validateSandboxConfiguration(options);
@@ -131,14 +160,42 @@ export class Sandbox {
     session(id = `sandbox-${this.id}`, options = {}) {
         return new ExecutionSession(this, id, options);
     }
+    /** A session by id: its saved settings, or a fresh session of that id, as
+     * Cloudflare starts one again after its shell ended. */
+    async sessionFor(id) {
+        if (id === undefined || id === `sandbox-${this.id}`)
+            return this.session();
+        try {
+            return await this.getSession(id);
+        }
+        catch (error) {
+            if (error instanceof NotFoundError)
+                return this.session(id);
+            throw error;
+        }
+    }
     exec(command, options) {
         return this.session().exec(command, options);
     }
-    execStream(command, options) {
-        return this.session().execStream(command, options);
+    async execWithSessionToken(command, sessionId, options) {
+        return (await this.sessionFor(sessionId)).exec(command, options);
     }
-    startProcess(command, options = {}) {
-        return this.session(options.sessionId).startProcess(command, options);
+    async execStream(command, options = {}) {
+        const { sessionId, bufferSize, ...rest } = options;
+        if (bufferSize !== undefined && (!Number.isSafeInteger(bufferSize) || bufferSize <= 0))
+            throw new TypeError("bufferSize must be a positive integer");
+        return (await this.sessionFor(sessionId)).execStream(command, rest);
+    }
+    execStreamWithSessionToken(command, sessionId, options = {}) {
+        return this.execStream(command, { ...options, sessionId });
+    }
+    async startProcess(command, options = {}) {
+        if (options.processId !== undefined)
+            throw new CompatibilityError("Cloudflare", "processId; Runtime names each process itself");
+        if (options.autoCleanup)
+            throw new CompatibilityError("Cloudflare", "autoCleanup; Runtime keeps a finished process's record and output until the sandbox ends");
+        const { autoCleanup: _kept, ...rest } = options;
+        return this.session(options.sessionId).startProcess(command, rest);
     }
     async createSession(options = {}) {
         only("Cloudflare session", options, [
@@ -175,32 +232,74 @@ export class Sandbox {
     async setEnvVars(env) {
         const s = await this.native();
         await saveEnvironment(s, { ...(await environment(s)), ...cleanEnv(env) });
+        this.envVars = { ...this.envVars, ...cleanEnv(env) };
     }
-    writeFile(path, content, options) {
-        return this.session().writeFile(path, content, options);
+    /** Stops the sandbox; its files stay, and the next call starts it again. */
+    async stop(signal) {
+        if (signal !== undefined)
+            throw new CompatibilityError("Cloudflare", "a stop signal; Runtime stops every process");
+        await (await this.native()).stop();
+    }
+    async writeFile(path, content, options = {}) {
+        const { sessionId, ...rest } = options;
+        return (await this.sessionFor(sessionId)).writeFile(path, content, rest);
     }
-    readFile(path, options) {
-        return options?.encoding === "none"
-            ? this.session().readFile(path, { encoding: "none" })
-            : this.session().readFile(path, options);
+    async readFile(path, options = {}) {
+        const { sessionId, encoding } = options;
+        const session = await this.sessionFor(sessionId);
+        return encoding === "none"
+            ? session.readFile(path, { encoding: "none" })
+            : session.readFile(path, { encoding });
+    }
+    /** The file as Cloudflare streams it: `data:` lines of a metadata event,
+     * chunks (base64 for a binary file) and a complete event; read it with
+     * streamFile() or collectFile(). */
+    async readFileStream(path, options = {}) {
+        const read = await this.readFile(path, { encoding: "none", sessionId: options.sessionId });
+        const bytes = new Uint8Array(await new Response(read.content).arrayBuffer());
+        const text = new TextDecoder().decode(bytes);
+        const isBinary = text.includes("\0") || text.includes("\ufffd");
+        return sseStream(async (send) => {
+            send({
+                type: "metadata",
+                mimeType: isBinary ? "application/octet-stream" : "text/plain",
+                size: bytes.length,
+                isBinary,
+                encoding: isBinary ? "base64" : "utf-8",
+            });
+            const CHUNK = 65_536;
+            if (isBinary)
+                for (let i = 0; i < bytes.length; i += CHUNK) {
+                    let raw = "";
+                    for (const byte of bytes.subarray(i, i + CHUNK))
+                        raw += String.fromCharCode(byte);
+                    send({ type: "chunk", data: btoa(raw) });
+                }
+            else
+                for (let i = 0; i < text.length; i += CHUNK)
+                    send({ type: "chunk", data: text.slice(i, i + CHUNK) });
+            send({ type: "complete", bytesRead: bytes.length });
+        });
     }
-    mkdir(path, options) {
-        return this.session().mkdir(path, options);
+    async mkdir(path, options = {}) {
+        const { sessionId, ...rest } = options;
+        return (await this.sessionFor(sessionId)).mkdir(path, rest);
     }
-    deleteFile(path) {
-        return this.session().deleteFile(path);
+    async deleteFile(path, sessionId) {
+        return (await this.sessionFor(sessionId)).deleteFile(path);
     }
-    renameFile(from, to) {
-        return this.session().renameFile(from, to);
+    async renameFile(from, to, sessionId) {
+        return (await this.sessionFor(sessionId)).renameFile(from, to);
     }
-    moveFile(from, to) {
-        return this.renameFile(from, to);
+    moveFile(from, to, sessionId) {
+        return this.renameFile(from, to, sessionId);
     }
-    listFiles(path, options) {
-        return this.session().listFiles(path, options);
+    async listFiles(path, options = {}) {
+        const { sessionId, ...rest } = options;
+        return (await this.sessionFor(sessionId)).listFiles(path, rest);
     }
-    exists(path) {
-        return this.session().exists(path);
+    async exists(path, sessionId) {
+        return (await this.sessionFor(sessionId)).exists(path);
     }
     async listProcesses() {
         const s = await this.native();
@@ -262,6 +361,270 @@ export class Sandbox {
     async unexposePort(port) {
         await (await this.native()).previews.delete(port);
     }
+    /** Runtime's previews have their own addresses: hostname is not used to build them. */
+    async getExposedPorts(_hostname) {
+        return (await (await this.native()).previews.list()).map((p) => ({
+            url: p.urlWithToken ?? p.url,
+            port: p.port,
+            status: "active",
+        }));
+    }
+    async isPortExposed(port) {
+        if (!Number.isInteger(port) || port < 1 || port > 65535)
+            return false;
+        return (await (await this.native()).previews.list()).some((p) => p.port === port);
+    }
+    /** Cloudflare's returns 0 too: a process's record outlives it on both. */
+    async cleanupCompletedProcesses(_sessionId) {
+        return 0;
+    }
+    /** The process's output as `data:` lines of stdout, stderr and exit events. */
+    async streamProcessLogs(processId, options = {}) {
+        only("Cloudflare streamProcessLogs", options, ["signal"]);
+        options.signal?.throwIfAborted();
+        const p = await (await this.native()).processes.get(processId);
+        return sseStream(async (send, cancelled) => {
+            const signal = options.signal ? AbortSignal.any([options.signal, cancelled]) : cancelled;
+            for await (const e of p.output({ signal })) {
+                const at = new Date().toISOString();
+                if (e.type === "stdout" || e.type === "stderr")
+                    send({ type: e.type, timestamp: at, data: e.data, processId });
+                else if (e.type === "exit")
+                    send({ type: "exit", timestamp: at, data: "", processId, exitCode: e.exitCode });
+                else if (e.type === "truncated")
+                    send({ type: "error", timestamp: at, data: "Process output was truncated", processId });
+            }
+        });
+    }
+    /** Clones with git in the sandbox, as Cloudflare's container does. */
+    async gitCheckout(repoUrl, options = {}) {
+        only("Cloudflare gitCheckout", options, [
+            "branch",
+            "targetDir",
+            "sessionId",
+            "depth",
+            "cloneTimeoutMs",
+        ]);
+        const timeout = options.cloneTimeoutMs ?? 600_000;
+        if (options.depth !== undefined && (!Number.isInteger(options.depth) || options.depth <= 0))
+            throw new Error(`Invalid depth value: ${options.depth}. Must be a positive integer (e.g., 1, 5, 10).`);
+        if (!Number.isInteger(timeout) || timeout <= 0)
+            throw new Error(`Invalid timeout value: ${timeout}. Must be a positive integer number of milliseconds.`);
+        const name = repoUrl
+            .replace(/\/+$/, "")
+            .split(/[/:]/)
+            .pop()
+            ?.replace(/\.git$/, "") || "repo";
+        const targetDir = options.targetDir ?? `/workspace/${name}`;
+        const session = await this.sessionFor(options.sessionId);
+        const args = [
+            "git clone",
+            ...(options.branch ? ["--branch", quote(options.branch)] : []),
+            ...(options.depth ? ["--depth", String(options.depth)] : []),
+            "--",
+            quote(repoUrl),
+            quote(targetDir),
+        ];
+        const clone = await session.exec(`${args.join(" ")} && git -C ${quote(targetDir)} rev-parse --abbrev-ref HEAD`, { timeout });
+        if (!clone.success)
+            throw new Error(`Failed to clone ${repoUrl}: ${clone.stderr.trim() || clone.stdout.trim()}`);
+        return {
+            success: true,
+            repoUrl,
+            branch: options.branch ?? clone.stdout.trim().split("\n").pop(),
+            targetDir,
+            timestamp: new Date().toISOString(),
+            exitCode: clone.exitCode,
+        };
+    }
+    /** Changes under a directory as `data:` lines of Cloudflare's watch events,
+     * once the watch is established, until the stream is cancelled. */
+    async watch(path, options = {}) {
+        only("Cloudflare watch", options, ["recursive", "include", "exclude", "sessionId"]);
+        const filters = watchFilters(options);
+        const directory = await (await this.sessionFor(options.sessionId)).resolve(path);
+        const encode = new TextEncoder();
+        let stream;
+        let closed = false;
+        const send = (event) => {
+            if (!closed)
+                stream.enqueue(encode.encode(`data: ${JSON.stringify(event)}\n\n`));
+        };
+        const handle = await (await this.native()).files.watch(directory, (e) => {
+            const timestamp = new Date().toISOString();
+            const event = (eventType, at) => send({ type: "event", eventType, path: at, isDirectory: e.isDir, timestamp });
+            if (e.type === "rename") {
+                if (e.oldPath)
+                    event("move_from", e.oldPath);
+                event("move_to", e.path);
+            }
+            else
+                event({ create: "create", write: "modify", remove: "delete", chmod: "attrib" }[e.type] ?? e.type, e.path);
+        }, {
+            recursive: options.recursive ?? true,
+            ...filters,
+            timeoutMs: 0,
+            onNotice: (n) => send({ type: "error", error: n.k === "overflow" ? "Events were lost" : `Watch ${n.k}` }),
+            onExit: (reason) => {
+                send({ type: "stopped", reason });
+                if (!closed) {
+                    closed = true;
+                    stream.close();
+                }
+            },
+        });
+        return new ReadableStream({
+            start(controller) {
+                stream = controller;
+                send({ type: "watching", path: directory, watchId: handle.id });
+            },
+            async cancel() {
+                closed = true;
+                await handle.stop();
+            },
+        });
+    }
+    /** Whether anything under a path changed since a version this returned:
+     * the version is a digest of every entry's path, size, time and mode, tied
+     * to this boot of the sandbox. */
+    async checkChanges(path, options = {}) {
+        only("Cloudflare checkChanges", options, [
+            "since",
+            "recursive",
+            "include",
+            "exclude",
+            "sessionId",
+        ]);
+        const filters = watchFilters(options);
+        const session = await this.sessionFor(options.sessionId);
+        const r = await (await this.native()).exec([
+            "python3",
+            "-c",
+            CHANGES,
+            await session.resolve(path),
+            options.recursive === false ? "0" : "1",
+            JSON.stringify(filters.include ?? []),
+            JSON.stringify(filters.exclude ?? []),
+        ]);
+        if (r.exitCode !== 0)
+            throw new Error(`checkChanges failed: ${r.stderr.trim()}`);
+        const version = r.stdout.trim();
+        const timestamp = new Date().toISOString();
+        if (options.since === undefined || options.since === version)
+            return {
+                success: true,
+                status: options.since === undefined ? "changed" : "unchanged",
+                version,
+                timestamp,
+            };
+        return options.since.split(".")[0] === version.split(".")[0]
+            ? { success: true, status: "changed", version, timestamp }
+            : { success: true, status: "resync", reason: "restarted", version, timestamp };
+    }
+    /** Mounts an S3, R2 or Google Cloud Storage bucket with Runtime's mounts. A
+     * private bucket needs a Runtime secret: store its keys with
+     * runtime.secrets.set and mount with sandbox.mounts.add({ secret }). */
+    async mountBucket(bucket, mountPath, options) {
+        only("Cloudflare mountBucket", options, [
+            "endpoint",
+            "provider",
+            "credentials",
+            "readOnly",
+            "s3fsOptions",
+            "prefix",
+            "credentialProxy",
+            "localBucket",
+        ]);
+        if (options.credentials || options.credentialProxy)
+            throw new CompatibilityError("Cloudflare", "credentials in mountBucket; store them with runtime.secrets.set and mount with sandbox.mounts.add({ secret })");
+        if (options.s3fsOptions?.length)
+            throw new CompatibilityError("Cloudflare", "s3fsOptions; Runtime mounts with its own client");
+        if (options.localBucket || options.endpoint === undefined)
+            throw new CompatibilityError("Cloudflare", "an R2 binding; give the bucket's endpoint, https://<account>.r2.cloudflarestorage.com");
+        if (!mountPath.startsWith("/"))
+            throw new InvalidMountConfigError(`Mount path must be absolute: ${mountPath}`);
+        let host;
+        try {
+            host = new URL(options.endpoint).hostname;
+        }
+        catch {
+            throw new InvalidMountConfigError(`Invalid endpoint URL: ${options.endpoint}`);
+        }
+        const r2 = /^([a-f0-9]{32})\.r2\.cloudflarestorage\.com$/.exec(host);
+        const provider = options.provider ?? (r2 ? "r2" : host === "storage.googleapis.com" ? "gcs" : "s3");
+        const prefix = options.prefix?.replace(/^\/+|\/+$/g, "") || undefined;
+        try {
+            await (await this.native()).mounts.add({
+                provider,
+                bucket,
+                path: mountPath,
+                ...(prefix ? { prefix } : {}),
+                ...(provider === "r2" && r2
+                    ? { accountId: r2[1] }
+                    : provider === "gcs"
+                        ? {}
+                        : { endpoint: `https://${host}` }),
+                ...(options.readOnly !== undefined ? { readOnly: options.readOnly } : {}),
+            });
+        }
+        catch (error) {
+            throw new S3FSMountError(`Failed to mount ${bucket} at ${mountPath}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    async unmountBucket(mountPath) {
+        try {
+            await (await this.native()).mounts.remove(mountPath);
+        }
+        catch (error) {
+            throw new BucketUnmountError(`Failed to unmount ${mountPath}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    createCodeContext(options) {
+        return this.#interpreter.createCodeContext(options);
+    }
+    async runCode(code, options = {}) {
+        if (hasEnv(options.envVars))
+            throw new CompatibilityError("Cloudflare", RUN_ENV);
+        return (await this.#interpreter.runCode(code, options)).toJSON();
+    }
+    runCodeStream(code, options = {}) {
+        if (hasEnv(options.envVars))
+            throw new CompatibilityError("Cloudflare", RUN_ENV);
+        return this.#interpreter.runCodeStream(code, options);
+    }
+    listCodeContexts() {
+        return this.#interpreter.listCodeContexts();
+    }
+    deleteCodeContext(contextId) {
+        return this.#interpreter.deleteCodeContext(contextId);
+    }
+}
+refuse("Cloudflare", "Sandbox", Sandbox, {
+    client: "Runtime's API is the client; use the Sandbox methods",
+    tunnels: "use exposePort for a public URL",
+    callTunnels: "use exposePort for a public URL",
+    setSandboxName: "the name is getSandbox's id",
+    setContainerTimeouts: "Runtime starts a sandbox in under a second, with nothing to tune",
+    setTransport: "Runtime's API is the only transport",
+    onStart: "a Runtime sandbox has no Durable Object lifecycle hooks",
+    onStop: "a Runtime sandbox has no Durable Object lifecycle hooks",
+    onActivityExpired: "set sleepAfter or keepAlive instead",
+    fetch: "fetch the URL exposePort returns",
+    containerFetch: "fetch the URL exposePort returns",
+    wsConnect: "connect to the URL exposePort returns",
+    getContainerPlacementId: "a Runtime sandbox's id is its place",
+    validatePortToken: "Runtime checks preview tokens itself",
+    createBackup: "snapshot the sandbox with Runtime's snapshots, or keep the folder on a volume",
+    restoreBackup: "create a sandbox from a Runtime snapshot",
+});
+refuse("Cloudflare", "Sandbox", Sandbox, { onError: "a Runtime sandbox has no Durable Object lifecycle hooks" }, { sync: true });
+/** Cloudflare's Worker-side terminal proxy has no Runtime counterpart. */
+export async function proxyTerminal(..._args) {
+    throw new CompatibilityError("Cloudflare", "proxyTerminal; open a terminal with the native Runtime sandbox's terminal()");
+}
+/** Runtime previews are served by Runtime, not through your Worker. */
+export async function proxyToSandbox(..._args) {
+    throw new CompatibilityError("Cloudflare", "proxyToSandbox; Runtime serves the URLs exposePort returns itself");
 }
 export class ExecutionSession {
     sandbox;
@@ -283,7 +646,10 @@ export class ExecutionSession {
             "onComplete",
             "onError",
             "signal",
+            "origin",
         ]);
+        if (options.origin !== undefined && !["user", "internal"].includes(options.origin))
+            throw new TypeError("origin is user or internal");
         if (options.encoding && !["utf8", "utf-8"].includes(options.encoding))
             throw new CompatibilityError("Cloudflare", `process encoding ${options.encoding}`);
         const s = await this.sandbox.native();
@@ -413,6 +779,10 @@ export class ExecutionSession {
             })().catch((e) => options.onError?.(e instanceof Error ? e : new Error(String(e))));
         return process;
     }
+    /** A path as this session sees it: relative paths from its working directory. */
+    resolve(path) {
+        return this.path(path);
+    }
     async path(path) {
         if (path.startsWith("/"))
             return path;
@@ -566,13 +936,26 @@ export class Process {
     }
     async waitForExit(timeout) {
         const r = await this.native.wait({
-            signal: timeout ? AbortSignal.timeout(timeout) : undefined,
+            signal: timeout ? timeoutSignal(timeout) : undefined,
         });
         return { exitCode: r.exitCode ?? -1 };
     }
     async waitForLog(pattern, timeout = 30000) {
+        const condition = `log pattern ${String(pattern)}`;
+        const context = { processId: this.id, command: this.command, condition };
+        const signal = timeoutSignal(timeout);
+        try {
+            return await this.#waitForLog(pattern, signal);
+        }
+        catch (error) {
+            if (!signal.aborted)
+                throw error;
+            throw new ProcessReadyTimeoutError(response("PROCESS_READY_TIMEOUT", `Process did not become ready within ${timeout}ms`, { ...context, timeout }, { httpStatus: 408, operation: "process.start" }));
+        }
+    }
+    async #waitForLog(pattern, signal) {
         let output = "";
-        for await (const e of this.native.output({ signal: AbortSignal.timeout(timeout) })) {
+        for await (const e of this.native.output({ signal })) {
             if (e.type === "stdout" || e.type === "stderr") {
                 output += e.data;
                 const match = typeof pattern === "string" ? output.includes(pattern) : output.match(pattern);
@@ -586,7 +969,14 @@ export class Process {
                         ...(typeof pattern === "string" ? {} : { match }),
                     };
             }
+            else if (e.type === "exit")
+                throw new ProcessExitedBeforeReadyError(response("PROCESS_EXITED_BEFORE_READY", "Process exited before expected output", {
+                    processId: this.id,
+                    command: this.command,
+                    condition: `log pattern ${String(pattern)}`,
+                    exitCode: e.exitCode ?? -1,
+                }, { httpStatus: 409, operation: "process.start" }));
         }
-        throw new Error("Process exited before expected output");
+        throw new Error("Process output ended before expected output");
     }
 }

package/dist/cloudflare/interpreter.d.ts

@@ -0,0 +1,119 @@
+import type { Sandbox as NativeSandbox } from "../sandbox.js";
+type Language = "python" | "javascript" | "typescript";
+export interface CreateContextOptions {
+    language?: Language;
+    cwd?: string;
+    envVars?: Record<string, string | undefined>;
+    timeout?: number;
+}
+export interface CodeContext {
+    readonly id: string;
+    readonly language: string;
+    readonly cwd: string;
+    readonly createdAt: Date;
+    readonly lastUsed: Date;
+}
+export interface OutputMessage {
+    text: string;
+    timestamp: number;
+}
+export interface ExecutionError {
+    name: string;
+    message: string;
+    traceback: string[];
+    lineNumber?: number;
+}
+export interface RunCodeOptions {
+    context?: CodeContext;
+    language?: Language;
+    envVars?: Record<string, string | undefined>;
+    timeout?: number;
+    signal?: AbortSignal;
+    onStdout?: (output: OutputMessage) => void | Promise<void>;
+    onStderr?: (output: OutputMessage) => void | Promise<void>;
+    onResult?: (result: Result) => void | Promise<void>;
+    onError?: (error: ExecutionError) => void | Promise<void>;
+}
+declare const FORMATS: {
+    readonly text: "text/plain";
+    readonly html: "text/html";
+    readonly png: "image/png";
+    readonly jpeg: "image/jpeg";
+    readonly svg: "image/svg+xml";
+    readonly latex: "text/latex";
+    readonly markdown: "text/markdown";
+    readonly javascript: "application/javascript";
+    readonly json: "application/json";
+};
+type Fields = {
+    -readonly [K in keyof typeof FORMATS]?: K extends "json" ? unknown : string;
+};
+/** One rich result, as Cloudflare's: each format by name, the MIME bundle in
+ * `data`. `chart` is never set on Runtime. */
+export declare class Result implements Fields {
+    text?: string;
+    html?: string;
+    png?: string;
+    jpeg?: string;
+    svg?: string;
+    latex?: string;
+    markdown?: string;
+    javascript?: string;
+    json?: unknown;
+    chart?: undefined;
+    data?: Record<string, unknown>;
+    constructor(data: Record<string, unknown>);
+    formats(): string[];
+}
+export declare class Execution {
+    readonly code: string;
+    readonly context: CodeContext;
+    results: Result[];
+    logs: {
+        stdout: string[];
+        stderr: string[];
+    };
+    error?: ExecutionError;
+    executionCount?: number;
+    constructor(code: string, context: CodeContext);
+    toJSON(): {
+        code: string;
+        logs: {
+            stdout: string[];
+            stderr: string[];
+        };
+        error: ExecutionError | undefined;
+        executionCount: number | undefined;
+        results: {
+            text: string | undefined;
+            html: string | undefined;
+            png: string | undefined;
+            jpeg: string | undefined;
+            svg: string | undefined;
+            latex: string | undefined;
+            markdown: string | undefined;
+            javascript: string | undefined;
+            json: unknown;
+            chart: undefined;
+            data: Record<string, unknown> | undefined;
+        }[];
+    };
+}
+export declare const RUN_ENV = "envVars on a run; set them when making the context with createCodeContext({ envVars })";
+export declare const hasEnv: (env: Record<string, string | undefined> | undefined) => boolean;
+/** Cloudflare's code interpreter on Runtime's: Python, JavaScript and
+ * TypeScript contexts whose variables persist between runs. */
+export declare class CodeInterpreter {
+    #private;
+    constructor(sandbox: {
+        native(): Promise<NativeSandbox>;
+    } | (() => Promise<NativeSandbox>));
+    createCodeContext(options?: CreateContextOptions): Promise<CodeContext>;
+    runCode(code: string, options?: RunCodeOptions): Promise<Execution>;
+    /** The run as Cloudflare's container streams it: `data:` lines of stdout,
+     * stderr, result, error and execution_complete events. */
+    runCodeStream(code: string, options?: RunCodeOptions): Promise<ReadableStream>;
+    listCodeContexts(): Promise<CodeContext[]>;
+    deleteCodeContext(contextId: string): Promise<void>;
+}
+export {};