zidane 7.2.5 → 8.0.4

package/dist/contexts/docker.js

@@ -1,456 +1 @@
-import { n as globFilesViaShell, t as fileSizeViaExec } from "../exec-file-size-BRpoB6Io.js";
-import { a as outputExceededMessage, n as appendCapped, t as DEFAULT_MAX_OUTPUT_BUFFER } from "../output-cap-C9zukcCj.js";
-import { t as alwaysQuote } from "../shell-quote-BmnhZmdM.js";
-import { posix } from "node:path";
-import { Buffer } from "node:buffer";
-//#region src/contexts/docker.ts
-/**
-* `readFile` transport cap: headroom above the whole-read tool ceiling
-* (256MB in tools/whole-read-guard.ts) so tool policy — not the docker
-* transport — decides read limits, keeping refusal behavior consistent
-* across contexts. Still bounded: a probe-failure path can't buffer
-* more than this into host memory.
-*/
-const READ_FILE_MAX_BUFFER = 512 * 1024 * 1024;
-/**
-* dockerode surfaces HTTP errors with a `statusCode`. 304 = container
-* already stopped, 404 = already gone — both are fine during teardown.
-*/
-function isGoneOrAlreadyStopped(err) {
-	const code = err?.statusCode;
-	return code === 304 || code === 404;
-}
-function createDockerContext(config) {
-	let counter = 0;
-	const containers = /* @__PURE__ */ new Map();
-	const defaultImage = config?.image ?? "oven/bun:latest";
-	const defaultCwd = config?.cwd ?? "/workspace";
-	const defaultEnv = config?.env;
-	const defaultLimits = config?.limits;
-	const defaultMounts = config?.mounts ?? [];
-	const defaultName = config?.name;
-	async function getDockerode() {
-		try {
-			const Dockerode = (await import("dockerode")).default;
-			return new Dockerode();
-		} catch {
-			throw new Error("dockerode is required for Docker execution context. Install it with: bun add dockerode");
-		}
-	}
-	/**
-	* The exec transport with an explicit output cap. The public `exec`
-	* uses the shared 10MB default; `readFile` passes headroom above the
-	* whole-read tool ceiling so docker's EFFECTIVE read limit matches
-	* every other context (the fileSize probe refuses oversized files
-	* before this ever runs — the transport cap is the safety net for
-	* probe-failure paths, not the primary bound).
-	*/
-	async function execCapped(handle, command, options, maxBuffer) {
-		const ref = containers.get(handle.id);
-		if (!ref) throw new Error(`Container ${handle.id} not found`);
-		const execCwd = options?.cwd ?? handle.cwd;
-		const env = options?.env ? Object.entries(options.env).map(([k, v]) => `${k}=${v}`) : [];
-		const timeout = options?.timeout ?? defaultLimits?.timeout ?? 30;
-		const exec = await ref.container.exec({
-			Cmd: [
-				"timeout",
-				String(timeout),
-				"sh",
-				"-c",
-				command
-			],
-			WorkingDir: execCwd,
-			Env: env,
-			AttachStdout: true,
-			AttachStderr: true
-		});
-		const stream = await exec.start({ Detach: false });
-		return new Promise((resolve) => {
-			const stdoutSlot = {
-				text: "",
-				bytes: 0
-			};
-			const stderrSlot = {
-				text: "",
-				bytes: 0
-			};
-			let resolved = false;
-			const overflow = () => {
-				if (resolved) return;
-				resolved = true;
-				try {
-					stream.destroy?.();
-				} catch {}
-				resolve({
-					stdout: stdoutSlot.text,
-					stderr: `${stderrSlot.text ? `${stderrSlot.text}\n` : ""}${outputExceededMessage(maxBuffer, "stream detached (server-side timeout reaps the process)")}`,
-					exitCode: 143
-				});
-			};
-			const cappedWrite = (slot) => (chunk) => {
-				if (appendCapped(slot, typeof chunk === "string" ? Buffer.from(chunk, "utf-8") : chunk, maxBuffer) !== "ok") overflow();
-				return true;
-			};
-			const stdoutSink = {
-				write: cappedWrite(stdoutSlot),
-				end() {},
-				on() {},
-				once() {},
-				emit() {
-					return true;
-				}
-			};
-			const stderrSink = {
-				write: cappedWrite(stderrSlot),
-				end() {},
-				on() {},
-				once() {},
-				emit() {
-					return true;
-				}
-			};
-			try {
-				ref.docker.modem.demuxStream(stream, stdoutSink, stderrSink);
-			} catch {
-				stream.on("data", (chunk) => {
-					cappedWrite(stdoutSlot)(chunk);
-				});
-			}
-			const timer = setTimeout(() => {
-				if (resolved) return;
-				resolved = true;
-				try {
-					stream.destroy?.();
-				} catch {}
-				resolve({
-					stdout: stdoutSlot.text,
-					stderr: stderrSlot.text ? `${stderrSlot.text}\n[timeout]` : "[timeout]",
-					exitCode: 124
-				});
-			}, timeout * 1e3 + 1e3);
-			stream.on("end", async () => {
-				if (resolved) return;
-				resolved = true;
-				clearTimeout(timer);
-				let exitCode;
-				let inspectNote = "";
-				try {
-					const inspect = await exec.inspect();
-					if (inspect.ExitCode == null) {
-						exitCode = -1;
-						inspectNote = "[exit code unavailable: exec still marked running by daemon]";
-					} else exitCode = inspect.ExitCode;
-				} catch (err) {
-					exitCode = -1;
-					inspectNote = `[exit code unavailable: exec inspect failed: ${err?.message ?? String(err)}]`;
-				}
-				resolve({
-					stdout: stdoutSlot.text,
-					stderr: inspectNote ? stderrSlot.text ? `${stderrSlot.text}\n${inspectNote}` : inspectNote : stderrSlot.text,
-					exitCode
-				});
-			});
-			stream.on("error", (err) => {
-				if (resolved) return;
-				resolved = true;
-				clearTimeout(timer);
-				resolve({
-					stdout: stdoutSlot.text,
-					stderr: stderrSlot.text ? `${stderrSlot.text}\n${err.message}` : err.message,
-					exitCode: 1
-				});
-			});
-		});
-	}
-	const ctx = {
-		type: "docker",
-		capabilities: {
-			shell: true,
-			filesystem: true,
-			glob: true,
-			network: true,
-			gpu: false,
-			stream: true
-		},
-		async spawn(overrides) {
-			const docker = await getDockerode();
-			const id = `docker-${++counter}`;
-			const image = overrides?.image ?? defaultImage;
-			const cwd = overrides?.cwd ?? defaultCwd;
-			const mounts = [...defaultMounts, ...overrides?.mounts ?? []];
-			const name = overrides?.name ?? defaultName;
-			try {
-				await docker.getImage(image).inspect();
-			} catch {
-				await new Promise((resolve, reject) => {
-					docker.pull(image, (err, stream) => {
-						if (err) return reject(err);
-						docker.modem.followProgress(stream, (err2) => {
-							err2 ? reject(err2) : resolve();
-						});
-					});
-				});
-			}
-			const limits = {
-				...defaultLimits,
-				...overrides?.limits
-			};
-			const hostConfig = {};
-			if (limits?.memory) hostConfig.Memory = limits.memory * 1024 * 1024;
-			if (limits?.cpu) hostConfig.NanoCpus = Number.parseFloat(limits.cpu) * 1e9;
-			const hardening = {
-				...config?.hardening,
-				...overrides?.hardening
-			};
-			if (hardening.dropAllCapabilities) hostConfig.CapDrop = ["ALL"];
-			if (hardening.noNewPrivileges) hostConfig.SecurityOpt = ["no-new-privileges"];
-			if (hardening.readonlyRootfs) hostConfig.ReadonlyRootfs = true;
-			if (hardening.pidsLimit != null) hostConfig.PidsLimit = hardening.pidsLimit;
-			const env = {
-				...defaultEnv,
-				...overrides?.env
-			};
-			const bindSpecs = buildBindSpecs(mounts);
-			if (bindSpecs.length > 0) hostConfig.Binds = bindSpecs;
-			const portSpec = overrides?.ports ?? config?.ports;
-			const exposedPorts = {};
-			const portBindings = {};
-			if (portSpec?.length) {
-				for (const p of portSpec) {
-					const key = `${p.container}/${p.proto ?? "tcp"}`;
-					exposedPorts[key] = {};
-					portBindings[key] = [{ HostPort: p.host == null ? "" : String(p.host) }];
-				}
-				hostConfig.PortBindings = portBindings;
-			}
-			const user = overrides?.user ?? config?.user;
-			const network = overrides?.network ?? config?.network;
-			if (network) hostConfig.NetworkMode = network;
-			const labels = {
-				...config?.labels,
-				...overrides?.labels
-			};
-			const container = await docker.createContainer({
-				...name ? { name: `${name}-${counter}-${Math.random().toString(36).slice(2, 8)}` } : {},
-				Image: image,
-				Cmd: ["sleep", "infinity"],
-				WorkingDir: cwd,
-				Env: Object.entries(env).map(([k, v]) => `${k}=${v}`),
-				HostConfig: hostConfig,
-				...Object.keys(exposedPorts).length ? { ExposedPorts: exposedPorts } : {},
-				...user ? { User: user } : {},
-				...Object.keys(labels).length ? { Labels: labels } : {}
-			});
-			try {
-				await container.start();
-			} catch (err) {
-				await container.remove({ force: true }).catch(() => {});
-				throw err;
-			}
-			const handle = {
-				id,
-				type: "docker",
-				cwd
-			};
-			containers.set(id, {
-				handle,
-				container,
-				docker
-			});
-			return handle;
-		},
-		async exec(handle, command, options) {
-			return execCapped(handle, command, options, DEFAULT_MAX_OUTPUT_BUFFER);
-		},
-		/**
-		* Live bidirectional stream to a process in the container — see
-		* `ExecutionContext.execStream` for the seam contract.
-		*
-		* Spawns the `docker exec -i` CLI (see the runtime note in the body for
-		* why dockerode's hijack API is off the table), which adds a requirement
-		* the rest of this context doesn't have: the docker CLI must be on
-		* PATH — everything else here talks straight to the daemon socket.
-		* Deliberately NOT wrapped in coreutils `timeout` the way `execCapped`
-		* is — this seam's whole purpose is processes that outlive a single
-		* request.
-		*/
-		async execStream(handle, command, options) {
-			const ref = containers.get(handle.id);
-			if (!ref) throw new Error(`Container ${handle.id} not found`);
-			options?.signal?.throwIfAborted();
-			const spawnChild = (await import("node:child_process")).spawn;
-			const { randomBytes } = await import("node:crypto");
-			const pidFile = `/tmp/.zidane-stream-${randomBytes(6).toString("hex")}.pid`;
-			const envPrefix = Object.entries(options?.env ?? {}).map(([k, v]) => `${k}=${alwaysQuote(v)} `).join("");
-			const quotedLeader = alwaysQuote(`echo $$ > ${pidFile}; exec ${envPrefix ? `env ${envPrefix}` : ""}sh -c ${alwaysQuote(command)}`);
-			const inner = `if setsid -w true 2>/dev/null; then exec setsid -w sh -c ${quotedLeader}; else exec sh -c ${quotedLeader}; fi`;
-			const child = spawnChild("docker", [
-				"exec",
-				"-i",
-				"-w",
-				options?.cwd ?? handle.cwd,
-				ref.container.id,
-				"sh",
-				"-c",
-				inner
-			], { stdio: [
-				"pipe",
-				"pipe",
-				"pipe"
-			] });
-			let spawnError = null;
-			child.on("error", (err) => {
-				spawnError = err;
-			});
-			const exited = new Promise((resolveExit) => {
-				child.once("close", (code, signalName) => {
-					resolveExit(code ?? (signalName === "SIGTERM" ? 143 : signalName ? 128 : 1));
-				});
-			});
-			let pid = -1;
-			for (let attempt = 0; attempt < 20 && pid <= 0; attempt++) {
-				const probe = await execCapped(handle, `cat ${pidFile} 2>/dev/null || true`, void 0, 4096).catch(() => null);
-				const parsed = Number.parseInt(probe?.stdout.trim() ?? "", 10);
-				if (Number.isFinite(parsed) && parsed > 0) {
-					pid = parsed;
-					break;
-				}
-				if (child.exitCode !== null) break;
-				await new Promise((r) => setTimeout(r, 50));
-			}
-			const kill = async () => {
-				if (pid > 0) await execCapped(handle, `kill -TERM -${pid} 2>/dev/null || kill -TERM ${pid} 2>/dev/null || true`, void 0, 4096).catch(() => {});
-				await execCapped(handle, `rm -f ${pidFile}`, void 0, 4096).catch(() => {});
-				if (child.exitCode === null && child.signalCode === null) child.kill("SIGTERM");
-			};
-			if (options?.signal) if (options.signal.aborted) kill();
-			else {
-				const onAbort = () => {
-					kill();
-				};
-				const detach = () => options.signal.removeEventListener("abort", onAbort);
-				options.signal.addEventListener("abort", onAbort, { once: true });
-				exited.then(detach, detach);
-			}
-			return {
-				pid,
-				stdout: child.stdout,
-				stderr: child.stderr,
-				write: async (data) => {
-					if (spawnError) throw spawnError;
-					const stdin = child.stdin;
-					if (!stdin || stdin.destroyed) throw new Error(`execStream: stdin is closed (container ${handle.id})`);
-					await new Promise((resolveWrite, rejectWrite) => {
-						stdin.write(data, (err) => err ? rejectWrite(err) : resolveWrite());
-					});
-				},
-				kill,
-				exited
-			};
-		},
-		async fileSize(handle, path) {
-			return fileSizeViaExec((command) => execCapped(handle, command, void 0, DEFAULT_MAX_OUTPUT_BUFFER), path);
-		},
-		async readFile(handle, path) {
-			const result = await execCapped(handle, `cat ${alwaysQuote(path)}`, void 0, READ_FILE_MAX_BUFFER);
-			if (result.exitCode !== 0) throw new Error(`Failed to read file: ${result.stderr}`);
-			return result.stdout;
-		},
-		async writeFile(handle, path, content, encoding = "utf-8") {
-			const bytes = typeof content === "string" ? Buffer.from(content, encoding) : content;
-			const ref = containers.get(handle.id);
-			if (!ref) throw new Error(`Container ${handle.id} not found`);
-			const dest = posix.isAbsolute(path) ? path : posix.join(handle.cwd, path);
-			const dir = posix.dirname(dest);
-			const name = posix.basename(dest);
-			if (!name || name === "." || name === ".." || path.endsWith("/")) throw new Error(`Failed to write file: invalid path ${path}`);
-			const mkdir = await ctx.exec(handle, `mkdir -p ${alwaysQuote(dir)}`);
-			if (mkdir.exitCode !== 0) throw new Error(`Failed to write file: ${mkdir.stderr}`);
-			const stagedName = `.zidane-write-${Math.random().toString(36).slice(2, 10)}.tmp`;
-			const staged = posix.join(dir, stagedName);
-			try {
-				await ref.container.putArchive(await packTarFile(stagedName, bytes), { path: dir });
-			} catch (err) {
-				throw new Error(`Failed to write file: ${err instanceof Error ? err.message : String(err)}`);
-			}
-			const write = await ctx.exec(handle, `cat ${alwaysQuote(staged)} > ${alwaysQuote(dest)}; rc=$?; rm -f ${alwaysQuote(staged)}; exit $rc`);
-			if (write.exitCode !== 0) {
-				await ctx.exec(handle, `rm -f ${alwaysQuote(staged)}`).catch(() => {});
-				throw new Error(`Failed to write file: ${write.stderr}`);
-			}
-		},
-		async listFiles(handle, path, options) {
-			if (options?.glob) return globFilesViaShell(path, (command) => ctx.exec(handle, command), options?.limit ?? 1e3);
-			const result = await ctx.exec(handle, `ls -1p ${alwaysQuote(path)}`);
-			if (result.exitCode !== 0) throw new Error(result.stderr.trim() || `ls failed with exit ${result.exitCode}`);
-			return result.stdout.trim().split("\n").filter(Boolean);
-		},
-		async getMappedPort(handle, containerPort) {
-			const ref = containers.get(handle.id);
-			if (!ref) return null;
-			const bindings = (await ref.container.inspect())?.NetworkSettings?.Ports ?? {};
-			for (const proto of ["tcp", "udp"]) {
-				const list = bindings[`${containerPort}/${proto}`];
-				if (Array.isArray(list) && list.length > 0 && list[0]?.HostPort) return Number.parseInt(list[0].HostPort, 10);
-			}
-			return null;
-		},
-		async destroy(handle) {
-			const ref = containers.get(handle.id);
-			if (!ref) return;
-			try {
-				try {
-					await ref.container.stop({ t: 5 });
-				} catch {}
-				try {
-					await ref.container.remove({ force: true });
-				} catch (err) {
-					if (!isGoneOrAlreadyStopped(err)) throw err;
-				}
-			} finally {
-				containers.delete(handle.id);
-			}
-		}
-	};
-	return ctx;
-}
-/**
-* Format one {@link ContextMount} as a dockerode `HostConfig.Binds` entry.
-* Supports read-only (`:ro`) and SELinux shared-label (`:z`) options; the two
-* are mutually exclusive (a read-only mount can't also be a shared rw mount).
-*/
-function formatBindMount(mount) {
-	if (!mount.source) throw new Error("Docker mount source is required");
-	if (!mount.target || !mount.target.startsWith("/")) throw new Error(`Docker mount target must be an absolute path: ${mount.target}`);
-	if (mount.readonly && mount.shared) throw new Error(`Docker mount cannot be both readonly and shared: ${mount.target}`);
-	const opts = mount.readonly ? ":ro" : mount.shared ? ":z" : "";
-	return `${mount.source}:${mount.target}${opts}`;
-}
-/** Assemble dockerode `HostConfig.Binds` from the context's `mounts`. */
-function buildBindSpecs(mounts) {
-	return mounts.map(formatBindMount);
-}
-/**
-* Pack a single file into an in-memory tar archive for `putArchive`, via
-* `tar-stream` (the same battle-tested packer the dockerode ecosystem uses
-* for build contexts). Optional peer dependency, loaded lazily like
-* dockerode itself so the module graph stays lean for non-docker users.
-*/
-async function packTarFile(name, data) {
-	let pack;
-	try {
-		pack = (await import("tar-stream")).pack;
-	} catch {
-		throw new Error("tar-stream is required for Docker writeFile. Install it with: bun add tar-stream");
-	}
-	const tar = pack();
-	tar.entry({ name }, data);
-	tar.finalize();
-	const chunks = [];
-	for await (const chunk of tar) chunks.push(chunk);
-	return Buffer.concat(chunks);
-}
-//#endregion
-export { READ_FILE_MAX_BUFFER, buildBindSpecs, createDockerContext, packTarFile };
-
-//# sourceMappingURL=docker.js.map
+export { i as READ_FILE_MAX_BUFFER, r as buildBindSpecs, t as createDockerContext, n as hostWorkspaceMounts, a as packTarFile } from "../docker-BZhMMJUp.js";

package/dist/contexts/e2b.d.ts

@@ -1,7 +1,10 @@
-import { rm as Logger } from "../index-BgN1T3lk.js";
-import { t as SandboxProvider } from "../sandbox-BH0WQkXn.js";
-
-//#region src/contexts/e2b.d.ts
+import { tp as Logger } from "../index-BGe1fQT7.js";
+import { t as SandboxProvider } from "../sandbox-C5dR5DwQ.js";
+//#region src/contexts/e2b-sdk.d.ts
+/**
+ * Structural `e2b` SDK views + env merge shared by the E2B provider modules.
+ * Internal module.
+ */
 /**
  * Options that flip `commands.run` into background mode. Split out so the
  * overload above can discriminate on it: `background: true` changes the
@@ -40,14 +43,43 @@ interface E2BCommandHandle {
   pid: number;
   wait: () => Promise<E2BCommandResult>;
 }
+/** The SDK's PTY `CommandHandle`, as far as terminals use it. */
+interface E2BPtyHandle {
+  pid: number;
+  wait: () => Promise<{
+    exitCode?: number;
+  }>;
+  disconnect: () => Promise<void>;
+}
+interface E2BPtyOutput {
+  onData: (data: Uint8Array) => void;
+  timeoutMs?: number;
+}
 interface E2BSandbox {
   sandboxId: string;
+  /** Interactive terminals (`sandbox.pty`); used only by `openTerminal`. */
+  pty?: {
+    create: (opts: E2BPtyOutput & {
+      cols: number;
+      rows: number;
+      cwd?: string;
+      envs?: Record<string, string>;
+    }) => Promise<E2BPtyHandle>;
+    connect: (pid: number, opts?: E2BPtyOutput) => Promise<E2BPtyHandle>;
+    sendInput: (pid: number, data: Uint8Array) => Promise<void>;
+    resize: (pid: number, size: {
+      cols: number;
+      rows: number;
+    }) => Promise<void>;
+    kill: (pid: number) => Promise<boolean>;
+  };
   commands: {
     run: ((cmd: string, opts?: {
       cwd?: string;
       envs?: Record<string, string>;
       timeoutMs?: number;
-    }) => Promise<E2BCommandResult>) & ((cmd: string, opts: E2BBackgroundOptions) => Promise<E2BCommandHandle>); /** Present from the SDK's Commands module; used only by `execStream`. */
+    }) => Promise<E2BCommandResult>) & ((cmd: string, opts: E2BBackgroundOptions) => Promise<E2BCommandHandle>);
+    /** Present from the SDK's Commands module; used only by `execStream`. */
     sendStdin?: (pid: number, data: string | Uint8Array) => Promise<void>;
     kill?: (pid: number) => Promise<boolean>;
   };
@@ -66,6 +98,23 @@ interface E2BSandbox {
   kill: () => Promise<unknown>;
   pause?: () => Promise<boolean>;
   betaPause?: () => Promise<boolean>;
+  /** Extend (or shorten) the sandbox's timeout from now — used by `keepAliveSeconds`. */
+  setTimeout?: (timeoutMs: number) => Promise<void>;
+}
+/**
+ * Merge the factory-level {@link E2BProviderOptions.env} with the per-spawn
+ * `SpawnConfig.env`, per-spawn winning on key conflicts. Returns `undefined`
+ * when the merge is empty so callers can skip setting `envs` on the create
+ * options entirely (rather than handing the SDK an empty object).
+ */
+declare function resolveE2BEnv(optionEnv: Record<string, string> | undefined, perSpawnEnv: Record<string, string> | undefined): Record<string, string> | undefined;
+//#endregion
+//#region src/contexts/e2b.d.ts
+/** What E2B does when a sandbox's timeout elapses (e2b SDK `SandboxLifecycle`). */
+interface E2BLifecycle {
+  onTimeout: 'pause' | 'kill';
+  /** Resume a paused sandbox on the next connect / request (needs `onTimeout: 'pause'`). */
+  autoResume?: boolean;
 }
 interface E2BProviderOptions {
   /** E2B API key. Falls back to the `E2B_API_KEY` env var when omitted. */
@@ -150,6 +199,19 @@ interface E2BProviderOptions {
    * their lifecycle.
    */
   onDestroy?: 'kill' | 'pause' | 'leave';
+  /**
+   * What happens when a created sandbox's timeout elapses. `{ onTimeout:
+   * 'pause', autoResume: true }` makes a timeout a pause instead of a kill —
+   * what long-lived sessions want. Default: E2B's (kill).
+   */
+  lifecycle?: E2BLifecycle;
+  /**
+   * Keep the sandbox alive while it's used: at most once a minute, any
+   * command or file call pushes its timeout out to this many seconds from
+   * now (`sandbox.setTimeout`). An idle sandbox still times out. Off when
+   * unset.
+   */
+  keepAliveSeconds?: number;
 }
 /**
  * Upload a setup ("pregame") script into a ready sandbox and execute it.
@@ -206,13 +268,6 @@ declare function waitForE2BReady(sandbox: E2BSandbox, logger: Logger, opts: E2BR
  * NOT `E2B_TEMPLATE`, so this provider has to honor it itself.
  */
 declare function resolveE2BTemplate(perSpawnTemplate: string | undefined, optionTemplate: string | undefined, env?: Record<string, string | undefined>): string | undefined;
-/**
- * Merge the factory-level {@link E2BProviderOptions.env} with the per-spawn
- * `SpawnConfig.env`, per-spawn winning on key conflicts. Returns `undefined`
- * when the merge is empty so callers can skip setting `envs` on the create
- * options entirely (rather than handing the SDK an empty object).
- */
-declare function resolveE2BEnv(optionEnv: Record<string, string> | undefined, perSpawnEnv: Record<string, string> | undefined): Record<string, string> | undefined;
 /**
  * Build a {@link SandboxProvider} backed by E2B.
  *
@@ -222,5 +277,5 @@ declare function resolveE2BEnv(optionEnv: Record<string, string> | undefined, pe
  */
 declare function createE2BProvider(options?: E2BProviderOptions): SandboxProvider;
 //#endregion
-export { E2BProviderOptions, E2BReadinessOptions, createE2BProvider, resolveE2BEnv, resolveE2BTemplate, runE2BPregame, waitForE2BReady };
+export { E2BLifecycle, E2BProviderOptions, E2BReadinessOptions, createE2BProvider, resolveE2BEnv, resolveE2BTemplate, runE2BPregame, waitForE2BReady };
 //# sourceMappingURL=e2b.d.ts.map

package/dist/contexts/e2b.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"e2b.d.ts","names":[],"sources":["../../src/contexts/e2b.ts"],"mappings":";;;;;;;;;;AAwGsC;AAAA;;;;UArC5B,oBAAA;EACR,UAAA;EACA,KAAA;EACA,SAAA;EACA,GAAA;EACA,IAAA,GAAO,MAAM;EACb,QAAA,IAAY,IAAA;EACZ,QAAA,IAAY,IAAA;AAAA;AAAA,UAYJ,gBAAA;EACR,MAAA;EACA,MAAA;EACA,QAAA;AAAA;AAAA,UAGQ,QAAA;EACR,IAAA;EAyCyB;EAvCzB,IAAI;AAAA;;;;;UAOI,gBAAA;EACR,GAAA;EACA,IAAA,QAAY,OAAO,CAAC,gBAAA;AAAA;AAAA,UAGZ,UAAA;EACR,SAAA;EACA,QAAA;IACE,GAAA,IAAO,GAAA,UAAa,IAAA;MAAS,GAAA;MAAc,IAAA,GAAO,MAAA;MAAwB,SAAA;IAAA,MAAyB,OAAA,CAAQ,gBAAA,OACrG,GAAA,UAAa,IAAA,EAAM,oBAAA,KAAyB,OAAA,CAAQ,gBAAA,IAE7C;IAAb,SAAA,IAAa,GAAA,UAAa,IAAA,WAAe,UAAA,KAAe,OAAA;IACxD,IAAA,IAAQ,GAAA,aAAgB,OAAA;EAAA;EAE1B,KAAA;IACE,IAAA,GAAO,IAAA,aAAiB,OAAA;IAHA;;;;;;;IAWxB,KAAA,GAAQ,IAAA,UAAc,IAAA,WAAe,UAAA,KAAe,OAAA;IACpD,IAAA,GAAO,IAAA,aAAiB,OAAA,CAAQ,QAAA;EAAA;EAElC,IAAA,QAAY,OAAA;EAKZ,KAAA,SAAc,OAAA;EACd,SAAA,SAAkB,OAAA;AAAA;AAAA,UA0BH,kBAAA;EAhCH;EAkCZ,MAAA;EA7Bc;;;;AACW;EAkCzB,MAAA;EARiC;;;;;EAcjC,QAAA;EASA;;;;;;;;EAAA,SAAA;EAuCY;;;;EAlCZ,GAAA;EA+EoB;;;;EA1EpB,cAAA;EA6E4D;;;;;EAvE5D,GAAA,GAAM,MAAA;EAsEE;;;;;EAhER,MAAA,GAAS,MAAM;EAiE6C;;;;AACpD;AA8BV;;EAxFE,uBAAA;EAqG+B;;;;;;;;EA5F/B,OAAA;IAAY,IAAA;IAAc,OAAA;EAAA;EA6GjB;;;;;;;;;;;;;;AAGD;AAmCV;EAlIE,SAAA;AAAA;;;;;;;AAqIqD;AAWvD;;;;;iBApHsB,aAAA,CACpB,OAAA,EAAS,UAAA,EACT,MAAA,EAAQ,MAAA,EACR,IAAA;EAAQ,IAAA;EAAc,OAAA;EAAiB,GAAA;EAAc,IAAA,GAAO,MAAA;AAAA,IAC3D,OAAA;AAAA,UA8Bc,mBAAA;EAqFd;EAnFD,cAAA;EAmFO;AAgBT;;;;;EA5FE,aAAA;EA4FmE;EA1FnE,GAAA;EA0FkF;EAxFlF,KAAA,IAAS,EAAA,aAAe,OAAO;AAAA;;;;;;;;;;;;;;iBAgBX,eAAA,CACpB,OAAA,EAAS,UAAA,EACT,MAAA,EAAQ,MAAA,EACR,IAAA,EAAM,mBAAA,GACL,OAAA;;;;;;;;iBAmCa,kBAAA,CACd,gBAAA,sBACA,cAAA,sBACA,GAAA,GAAK,MAAM;;;;;;;iBAWG,aAAA,CACd,SAAA,EAAW,MAAA,8BACX,WAAA,EAAa,MAAA,+BACZ,MAAA;;;;;;;;iBAgBa,iBAAA,CAAkB,OAAA,GAAS,kBAAA,GAA0B,eAAe"}
+{"version":3,"file":"e2b.d.ts","names":[],"sources":["../../src/contexts/e2b-sdk.ts","../../src/contexts/e2b.ts"],"mappings":";;;;;;;;;;;;;;;;;;UA2BiB;EACf;EACA;EACA;EACA;EACA,OAAO;EACP,YAAY;EACZ,YAAY;;UAYG;EACf;EACA;EACA;;UAGe;EACf;;EAEA;;;;;;UAOe;EACf;EACA,YAAY,QAAQ;;;UAIL;EACf;EACA,YAAY;IAAU;;EACtB,kBAAkB;;UAGH;EACf,SAAS,MAAM;EACf;;UAGe;EACf;;EAEA;IACE,SAAS,MAAM;MAAiB;MAAc;MAAc;MAAc,OAAO;UAA6B,QAAQ;IACtH,UAAU,aAAa,OAAO,iBAAiB,QAAQ;IACvD,YAAY,aAAa,MAAM,eAAe;IAC9C,SAAS,aAAa;MAAQ;MAAc;UAAmB;IAC/D,OAAO,gBAAgB;;EAEzB;IACE,OAAO,aAAa;MAAS;MAAc,OAAO;MAAwB;UAAyB,QAAQ,uBACrG,aAAa,MAAM,yBAAyB,QAAQ;;IAE1D,aAAa,aAAa,eAAe,eAAe;IACxD,QAAQ,gBAAgB;;EAE1B;IACE,OAAO,iBAAiB;;;;;;;;IAQxB,QAAQ,cAAc,eAAe,eAAe;IACpD,OAAO,iBAAiB,QAAQ;;EAElC,YAAY;EAKZ,cAAc;EACd,kBAAkB;;EAElB,cAAc,sBAAsB;;;;;;;;iBAStB,cACd,WAAW,oCACX,aAAa,qCACZ;;;;UC/Ec;EACf;;EAEA;;UA2Be;;EAEf;;;;;;EAMA;;;;;;EAMA;;;;;;;;;EASA;;;;;EAKA;;;;;EAKA;;;;;;EAMA,MAAM;;;;;;EAMN,SAAS;;;;;;;;EAQT;;;;;;;;;EASA;IAAY;IAAc;;;;;;;;;;;;;;;;;;EAiB1B;;;;;;EAMA,YAAY;;;;;;;EAOZ;;;;;;;;;;;;;;iBA+BoB,cACpB,SAAS,YACT,QAAQ,QACR;EAAQ;EAAc;EAAiB;EAAc,OAAO;IAC3D;UA8Bc;;EAEf;;;;;;;EAOA;;EAEA;;EAEA,SAAS,eAAe;;;;;;;;;;;;;;;iBAgBJ,gBACpB,SAAS,YACT,QAAQ,QACR,MAAM,sBACL;;;;;;;;iBAmCa,mBACd,sCACA,oCACA,MAAK;;;;;;;;iBAgBS,kBAAkB,UAAS,qBAA0B"}