From cc257e72c9a3ec2aa6cef37ac5f71490b70b6bfa Mon Sep 17 00:00:00 2001 From: Jakub Dobry Date: Mon, 15 Sep 2025 14:50:49 +0200 Subject: [PATCH 1/7] template sdk docs --- .gitignore | 1 + docs.json | 20 +- template/customization/authentication.mdx | 10 + template/customization/base-image.mdx | 153 +++++++ template/customization/build.mdx | 36 ++ template/customization/defining-template.mdx | 288 +++++++++++++ template/customization/error-handling.mdx | 42 ++ template/customization/logging.mdx | 74 ++++ .../customization/start-ready-command.mdx | 142 +++++++ template/examples.mdx | 380 ++++++++++++++++++ template/how-it-works.mdx | 28 ++ template/migration.mdx | 35 ++ template/quickstart.mdx | 194 +++++++++ 13 files changed, 1402 insertions(+), 1 deletion(-) create mode 100644 .gitignore create mode 100644 template/customization/authentication.mdx create mode 100644 template/customization/base-image.mdx create mode 100644 template/customization/build.mdx create mode 100644 template/customization/defining-template.mdx create mode 100644 template/customization/error-handling.mdx create mode 100644 template/customization/logging.mdx create mode 100644 template/customization/start-ready-command.mdx create mode 100644 template/examples.mdx create mode 100644 template/how-it-works.mdx create mode 100644 template/migration.mdx create mode 100644 template/quickstart.mdx diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..485dee6 --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +.idea diff --git a/docs.json b/docs.json index ace30e9..c5e20e4 100644 --- a/docs.json +++ b/docs.json @@ -31,7 +31,25 @@ }, { "group": "Custom sandbox", - "pages": ["Quickstart", "Overview"] + "pages": [ + "template/quickstart", + "template/how-it-works", + { + "group": "Customization", + "icon": "wand-magic-sparkles", + "pages": [ + "template/customization/authentication", + "template/customization/base-image", + "template/customization/defining-template", + "template/customization/start-ready-command", + "template/customization/build", + "template/customization/logging", + "template/customization/error-handling" + ] + }, + "template/examples", + "template/migration" + ] }, { "group": "Premade sandboxes", diff --git a/template/customization/authentication.mdx b/template/customization/authentication.mdx new file mode 100644 index 0000000..893c80f --- /dev/null +++ b/template/customization/authentication.mdx @@ -0,0 +1,10 @@ +--- +title: "Authentication" +description: "How to login to the E2B Cloud" +icon: "key" +--- + +The SDK uses environment variables for authentication: + +- `E2B_API_KEY`: Your E2B API key +- `E2B_DOMAIN`: (Optional) E2B domain, defaults to 'e2b.dev' diff --git a/template/customization/base-image.mdx b/template/customization/base-image.mdx new file mode 100644 index 0000000..f6eea7f --- /dev/null +++ b/template/customization/base-image.mdx @@ -0,0 +1,153 @@ +--- +title: "Base Image" +description: "How to define a base image for your template" +icon: "1" +--- + +### Creating template + +When creating a template, you can specify options: + + + +```typescript +const template = Template({ + fileContextPath: ".", // Custom file context path + ignoreFilePaths: [".git", "node_modules"], // File patterns to ignore +}); +``` + +```python +template = Template( + file_context_path=".", # Custom file context path + ignore_file_paths=[".git", "node_modules"], # File patterns to ignore +) +``` + + + +**File ignoring**: The SDK automatically reads `.dockerignore` files and combines them with your `ignoreFilePaths`. Files matching these patterns are excluded from uploads and hash calculations. + +### Defining base image +Choose from predefined base images or use custom ones: + + + +```typescript +// Predefined base images +template.fromUbuntuImage("lts"); // ubuntu:lts +template.fromUbuntuImage("22.04"); // ubuntu:22.04 +template.fromDebianImage("slim"); // debian:slim +template.fromDebianImage("bullseye"); // debian:bullseye +template.fromPythonImage("3.13"); // python:3.13 +template.fromPythonImage("3.11"); // python:3.11 +template.fromNodeImage("lts"); // node:lts +template.fromNodeImage("20"); // node:20 + +// Custom base image +template.fromImage("custom-image:latest"); + +// Use default E2B base image +template.fromBaseImage(); // e2bdev/base + +// Parse existing Dockerfile +const dockerfileContent = ` +FROM node:18-alpine +WORKDIR /app +COPY package*.json ./ +RUN npm ci --only=production +COPY . . +ENV NODE_ENV=production`; + +template.fromDockerfile(dockerfileContent); +``` + +```python +# Predefined base images +template.from_ubuntu_image("lts") # ubuntu:lts +template.from_ubuntu_image("22.04") # ubuntu:22.04 +template.from_debian_image("slim") # debian:slim +template.from_debian_image("bullseye") # debian:bullseye +template.from_python_image("3.13") # python:3.13 +template.from_python_image("3.11") # python:3.11 +template.from_node_image("lts") # node:lts +template.from_node_image("20") # node:20 + +# Custom base image +template.from_image("custom-image:latest") + +# Use default E2B base image +template.from_base_image() # e2bdev/base + +# Build from existing template +template.from_template("existing-template-alias") + +# Parse and build from Dockerfile +template.from_dockerfile("Dockerfile") +template.from_dockerfile("FROM ubuntu:22.04\nRUN apt-get update") +``` + + + + +You can only call base image methods once per template. Subsequent calls will throw an error. + + +### Parsing existing Dockerfiles + +Convert existing Dockerfiles to template format using `fromDockerfile()`: + + + +```typescript +const dockerfileContent = ` +FROM ubuntu:22.04 +RUN apt-get update && apt-get install -y curl +WORKDIR /app +COPY . . +ENV NODE_ENV=production +ENV PORT=3000 +USER appuser`; + +const template = Template() + .fromDockerfile(dockerfileContent) + .setStartCmd("npm start", waitForTimeout(5_000)); +``` + +```python +dockerfile_content = """ +FROM ubuntu:22.04 +RUN apt-get update && apt-get install -y curl +WORKDIR /app +COPY . . +ENV NODE_ENV=production +ENV PORT=3000 +USER appuser +""" + +template = ( + Template() + .from_dockerfile(dockerfile_content) + .set_start_cmd("npm start", wait_for_timeout(5_000)) +) +``` + + + +#### Dockerfile instructions support + +| Instruction | Supported | Behavior | +| :--- | :----: | :--- | +| `FROM` | | Sets base image | +| `RUN` | | Converts to `runCmd()` / `run_cmd()` | +| `COPY` / `ADD` | | Converts to `copy()` | +| `WORKDIR` | | Converts to `setWorkdir()` / `set_workdir()` | +| `USER` | | Converts to `setUser()` / `set_user()` | +| `ENV` | | Converts to `setEnvs()` / `set_envs()`; supports both `ENV key=value` and `ENV key value` formats | +| `CMD` / `ENTRYPOINT` | | Converts to `setStartCmd()` / `set_start_cmd()` with 20 seconds timeout as ready command | +| `EXPOSE` | | Skipped (not supported) | +| `VOLUME` | | Skipped (not supported) | + + +Multi-stage Dockerfiles are not supported. + diff --git a/template/customization/build.mdx b/template/customization/build.mdx new file mode 100644 index 0000000..add4383 --- /dev/null +++ b/template/customization/build.mdx @@ -0,0 +1,36 @@ +--- +title: "Build" +description: "How to build the template" +icon: "hammer" +--- + +Configure the build process: + + + +```typescript wrap +Template.build(template, { + alias: 'my-template', // Template alias (required) + cpuCount: 2, // CPU cores + memoryMB: 2048, // Memory in MB + skipCache: false, // Configure cache skip (except for files) + onBuildLogs: (logEntry) => console.log(logEntry.toString()), // Log callback receives LogEntry objects + apiKey: 'your-api-key', // Override API key + domain: 'your-domain', // Override domain +}) +``` + +```python wrap +Template.build( + template, + alias="my-template", # Template alias (required) + cpu_count=2, # CPU cores + memory_mb=2048, # Memory in MB + skip_cache=False, # Configure cache skip (except for files) + on_build_logs=lambda log_entry: print(log_entry), # Log callback receives LogEntry objects + api_key="your-api-key", # Override API key + domain="your-domain", # Override domain +) +``` + + diff --git a/template/customization/defining-template.mdx b/template/customization/defining-template.mdx new file mode 100644 index 0000000..2a6c6b3 --- /dev/null +++ b/template/customization/defining-template.mdx @@ -0,0 +1,288 @@ +--- +title: "Defining Template" +description: "How to create your own template" +icon: "2" +--- + +### Method chaining + +All template methods return the template instance, allowing for fluent API usage: + + + +```typescript +const template = Template() + .fromUbuntuImage("22.04") + .aptInstall(["curl"]) // necessary for waitForPort + .setWorkdir('/app') + .copy("package.json", "/app/package.json") + .runCmd("npm install") + .setStartCmd("npm start", waitForPort(3000)); +``` + +```python +template = ( + Template() + .from_ubuntu_image("22.04") + .set_workdir("/app") + .copy("package.json", "/app/package.json") + .run_cmd("npm install") + .set_start_cmd("npm start", wait_for_timeout(10_000))) +``` + + + +### User and workdir + +Set the working directory and user for the template: + + + +```typescript +// Set working directory +template.setWorkdir("/app"); + +// Set user (runs subsequent commands as this user) +template.setUser('node') +template.setUser("1000:1000"); // User ID and group ID +``` + +```python +# Set working directory +template.set_workdir("/app") + +# Set user (runs subsequent commands as this user) +template.set_user("node") +template.set_user("1000:1000") # User ID and group ID +``` + + + +### Copying files + +Copy files from your local filesystem to the template: + + + +```typescript +// Copy a single file +template.copy("package.json", "/app/package.json"); + +// Copy multiple files +template.copy([ + { src: "src/", dest: "/app/src/" }, + { src: "package.json", dest: "/app/package.json" }, +]); + +// Force upload (bypass cache) +template.copy("config.json", "/app/config.json", { forceUpload: true }); + +// Copy with user and mode options +template.copy("config.json", "/app/config.json", { + user: "appuser", + mode: 0o644, +}); +``` + +```python +# Copy a single file +template.copy("package.json", "/app/package.json") + +# Copy multiple files +template.copy([ + {"src": "src/", "dest": "/app/src/"}, + {"src": "package.json", "dest": "/app/package.json"}, +]) + +# Force upload (bypass cache) +template.copy("config.json", "/app/config.json", force_upload=True) +``` + + + +### File operations + +Perform various file operations during template build: + + + +```typescript +// Remove files or directories +template.remove("/tmp/temp-file.txt"); +template.remove("/old-directory", { recursive: true }); +template.remove("/file.txt", { force: true }); + +// Rename files or directories +template.rename("/old-name.txt", "/new-name.txt"); +template.rename("/old-dir", "/new-dir", { force: true }); + +// Create directories +template.makeDir("/app/logs"); +template.makeDir("/app/data", { mode: 0o755 }); + +// Create symbolic links +template.makeSymlink("/app/data", "/app/logs/data"); +``` + +```python +# Remove files or directories +template.remove("/tmp/old-file") +template.remove("/tmp/old-dir", recursive=True) +template.remove("/tmp/file", force=True) # Force removal + +# Rename files or directories +template.rename("/old/path", "/new/path") +template.rename("/old/path", "/new/path", force=True) # Force rename + +# Create directories +template.make_dir("/app/data") +template.make_dir("/app/data", mode=0o755) # Set permissions + +# Create symbolic links +template.make_symlink("/path/to/target", "/path/to/link") +``` + + + +### Installing packages + +Install packages using package managers: + + + +```typescript +// Install Python packages +template.pipInstall('requests pandas numpy') +template.pipInstall(['requests', 'pandas', 'numpy']) + +// Install Node.js packages +template.npmInstall('express lodash') +template.npmInstall(['express', 'lodash']) + +// Install system packages (automatically runs apt update) +template.aptInstall('curl wget git') +template.aptInstall(['curl', 'wget', 'git']) +``` + +```python +# Install Python packages +template.pip_install("requests pandas numpy") +template.pip_install(["requests", "pandas", "numpy"]) + +# Install Node.js packages +template.npm_install("express lodash") +template.npm_install(["express", "lodash"]) + +# Install system packages (Ubuntu/Debian) +template.apt_install("curl wget git") +template.apt_install(["curl", "wget", "git"]) +``` + + + +### Git operations + +Clone Git repositories during template build (requires `git` to be installed): + + + +```typescript +// Clone a repository +template.gitClone('https://github.com/user/repo.git', '/app/repo') + +// Clone a specific branch +template.gitClone('https://github.com/user/repo.git', '/app/repo', { + branch: 'main', +}) + +// Clone with depth limit +template.gitClone('https://github.com/user/repo.git', '/app/repo', { + depth: 1, +}) +``` + +```python +# Basic clone +template.git_clone("https://github.com/user/repo.git", "/app/repo") + +# Clone specific branch +template.git_clone("https://github.com/user/repo.git", "/app/repo", branch="main") + +# Shallow clone with depth limit +template.git_clone("https://github.com/user/repo.git", "/app/repo", depth=1) + +``` + + + +### Environment variables + +Set environment variables in the template: + + + +```typescript +template.setEnvs({ + NODE_ENV: 'production', + API_KEY: 'your-api-key', + DEBUG: 'true', +}) +``` + +```python +template.set_envs({ + "NODE_ENV": "production", + "API_KEY": "your-api-key", + "DEBUG": "true", +}) +``` + + + +### Invalidating caches + +Force rebuild from the next instruction: + + + +```typescript +template.skipCache() +``` + +```python +template.skip_cache() +``` + + + +This will invalidate the cache for all subsequent instructions in the template. + +### Running commands + +Execute shell commands during template build: + + + +```typescript +// Run a single command +template.runCmd('apt-get update && apt-get install -y curl') + +// Run multiple commands +template.runCmd(['apt-get update', 'apt-get install -y curl', 'curl --version']) + +// Run commands as a specific user +template.runCmd('npm install', { user: 'node' }) +``` + +```python +# Run a single command +template.run_cmd("apt-get update && apt-get install -y curl") + +# Run multiple commands +template.run_cmd(["apt-get update", "apt-get install -y curl", "curl --version"]) + +# Run command as specific user +template.run_cmd("npm install", user="node") +``` + + diff --git a/template/customization/error-handling.mdx b/template/customization/error-handling.mdx new file mode 100644 index 0000000..a730936 --- /dev/null +++ b/template/customization/error-handling.mdx @@ -0,0 +1,42 @@ +--- +title: "Error Handling" +description: "Handle errors in your template" +icon: "bug" +--- + +The SDK provides specific error types: + + + +```typescript +import { AuthError, BuildError, FileUploadError } from "e2b"; + +try { + await Template.build(template, { + alias: "my-template", + }); +} catch (error) { + if (error instanceof AuthError) { + console.error("Authentication failed:", error.message); + } else if (error instanceof FileUploadError) { + console.error("File upload failed:", error.message); + } else if (error instanceof BuildError) { + console.error("Build failed:", error.message); + } +} +``` + +```python +from e2b import AuthError, BuildError, FileUploadError + +try: + Template.build(template, alias="my-template") +except AuthError as error: + print(f"Authentication failed: {error}") +except FileUploadError as error: + print(f"File upload failed: {error}") +except BuildError as error: + print(f"Build failed: {error}") +``` + + diff --git a/template/customization/logging.mdx b/template/customization/logging.mdx new file mode 100644 index 0000000..421d250 --- /dev/null +++ b/template/customization/logging.mdx @@ -0,0 +1,74 @@ +--- +title: "Logging" +description: "How to view logs from the template build" +icon: "eye" +--- + +The `onBuildLogs`/`on_build_logs` callback receives structured `LogEntry` objects with the following properties: + + + +```typescript +type LogEntry = { + timestamp: Date + level: 'debug' | 'info' | 'warn' | 'error' + message: string + toString(): string // Returns formatted log string +} +``` + +```python +@dataclass +class LogEntry: + timestamp: datetime + level: Literal["debug", "info", "warn", "error"] + message: str + + def __str__(self) -> str: # Returns formatted log string +``` + + + + +You can customize how logs are handled: + + + +```typescript +// Simple logging +onBuildLogs: (logEntry) => console.log(logEntry.toString()); + +// Custom formatting +onBuildLogs: (logEntry) => { + const time = logEntry.timestamp.toISOString(); + console.log(`[${time}] ${logEntry.level.toUpperCase()}: ${logEntry.message}`); +}; + +// Filter by log level +onBuildLogs: (logEntry) => { + if (logEntry.level === "error" || logEntry.level === "warn") { + console.error(logEntry.toString()); + } +}; +``` + +```python +# Simple logging +on_build_logs=lambda log_entry: print(log_entry) + +# Custom formatting +def custom_logger(log_entry): + time = log_entry.timestamp.isoformat() + print(f"[{time}] {log_entry.level.upper()}: {log_entry.message}") + +Template.build(template, alias="my-template", on_build_logs=custom_logger) + +# Filter by log level +def error_logger(log_entry): + if log_entry.level in ["error", "warn"]: + print(f"ERROR/WARNING: {log_entry}", file=sys.stderr) + +Template.build(template, alias="my-template", on_build_logs=error_logger) +``` + + diff --git a/template/customization/start-ready-command.mdx b/template/customization/start-ready-command.mdx new file mode 100644 index 0000000..4568a9f --- /dev/null +++ b/template/customization/start-ready-command.mdx @@ -0,0 +1,142 @@ +--- +title: "Start & Ready Commands" +description: "Define running processes for the sandbox" +icon: "3" +--- + +## Start command +The start command allows you to specify a command that will be **already running** when you spawn your custom sandbox. +This way, you can for example have running servers or seeded databases inside the sandbox that are already fully ready when you spawn the sandbox using the SDK and with zero waiting time for your users during the runtime. + +The idea behind the start command feature is to lower the wait times for your users and have everything ready for your users when you spawn your sandbox. + +You can see how it works [here](/template/how-it-works). + +### Logs +You can retrieve the start command's logs using the SDK during runtime. + + +These logs are the logs from the start command during the build phase. + + + +```js {{ language: 'js' }} +import { Sandbox } from 'e2b' + +// Spawn your custom sandbox +const sandbox = await Sandbox.create({ + id: 'my-agent-sandbox', + // If you specify onStderr and onStdout handlers when spawning the sandbox + // you will see logs from the start command. + onStderr: output => console.log("stderr", output.line), // $HighlightLine + onStdout: output => console.log("stdout", output.line), // $HighlightLine +}) + +// Close sandbox once done +await sandbox.close() +``` + +```python {{ language: 'python' }} +from e2b import Sandbox + +# Spawn your custom sandbox +sandbox = Sandbox.create( + id="my-agent-sandbox", + # If you specify on_stderr and on_stdout handlers when spawning the sandbox + # you will see logs from the start command. + on_stderr=lambda output: print("stderr", output.line), # $HighlightLine + on_stdout=lambda output: print("stdout", output.line), # $HighlightLine +) + +# Close sandbox once done +sandbox.kill() +``` + + +Or you can use the CLI: + + +```bash {{ language: 'bash' }} +e2b sandbox logs +``` + + +## Ready command +The ready command allows you to specify a command that will determine **template sandbox** readiness before a [snapshot](/template/how-it-works) is created. +It is executed in an infinite loop until it returns a successful **exit code 0**. +This way you can control how long should we wait for the [start command](/template/customization/start-ready-command#start-command) or any system state. + +## Usage + +Set the command that runs when the sandbox starts and the command that determines when the sandbox is ready: + + + +```typescript +// Set both start command and ready command +template.setStartCmd('npm start', waitForPort(3000)) + +// Set only ready command +template.setReadyCmd('curl -f http://localhost:3000/health') +``` + +```python +# Set both start command and ready command +template.set_start_cmd("npm start", wait_for_timeout(10_000)) + +# Set only ready command +template.set_ready_cmd(wait_for_port(3000)) +``` + + + +The ready command is used to determine when the sandbox is ready to accept connections. + + + You can only call these commands once per template. Subsequent calls will throw an error. + + +## Ready command helpers + +The SDK provides helper functions for common ready command patterns: + + + +```typescript +import { + waitForPort, + waitForProcess, + waitForFile, + waitForTimeout, +} from 'e2b' + +// Wait for a port to be available +waitForPort(3000) + +// Wait for a process to be running +waitForProcess('node') + +// Wait for a file to exist +waitForFile('/app/ready.txt') + +// Wait for a timeout +waitForTimeout(10_000) // 10 seconds +``` + +```python +from e2b import wait_for_port, wait_for_process, wait_for_file, wait_for_timeout + +# Wait for a port to be available +wait_for_port(3000) + +# Wait for a process to be running +wait_for_process("nginx") + +# Wait for a file to exist +wait_for_file("/tmp/ready") + +# Wait for a specified duration +wait_for_timeout(10_000) # 10 seconds +``` + + diff --git a/template/examples.mdx b/template/examples.mdx new file mode 100644 index 0000000..5042cce --- /dev/null +++ b/template/examples.mdx @@ -0,0 +1,380 @@ +--- +title: "Examples" +description: "Examples of using the template" +icon: "book" +--- + +## Next.js + +Basic Next.js app with Tailwind and shadcn UI + + + +```typescript template.ts +import { Template, waitForPort } from 'e2b' + +export const template = Template() + .fromNodeImage('21-slim') + .setWorkdir('/home/user/nextjs-app') + .runCmd( + 'npx create-next-app@14.2.30 . --ts --tailwind --no-eslint --import-alias "@/*" --use-npm --no-app --no-src-dir' + ) + .runCmd('npx shadcn@2.1.7 init -d') + .runCmd('npx shadcn@2.1.7 add --all') + .runCmd( + 'mv /home/user/nextjs-app/* /home/user/ && rm -rf /home/user/nextjs-app' + ) + .setWorkdir('/home/user') + .setStartCmd('npx next --turbo', waitForPort(3000)) + +``` + + +```python template.py +from e2b import Template, wait_for_port + +template = ( + Template() + .from_node_image("21-slim") + .set_workdir("/home/user/nextjs-app") + .run_cmd( + 'npx create-next-app@14.2.30 . --ts --tailwind --no-eslint --import-alias "@/*" --use-npm --no-app --no-src-dir' + ) + .run_cmd("npx shadcn@2.1.7 init -d") + .run_cmd("npx shadcn@2.1.7 add --all") + .run_cmd("mv /home/user/nextjs-app/* /home/user/ && rm -rf /home/user/nextjs-app") + .set_workdir("/home/user") + .set_start_cmd("npx next --turbo", wait_for_port(3000)) +) +``` + + + + + +```typescript build.ts +import { Template } from 'e2b' +import { template as nextJSTemplate } from './template' + +Template.build(nextJSTemplate, { + alias: 'nextjs-app', + cpuCount: 1, + memoryMB: 1024, + onBuildLogs: (logEntry) => console.log(logEntry.toString()), +}) +``` + + +```python build.py +from e2b import Template +from .template import template as nextjsTemplate + +Template.build(nextjsTemplate, + alias="nextjs-app", + cpu_count=4, + memory_mb=4096, + on_build_logs=lambda log_entry: print(log_entry), +) +``` + + + +## Desktop + +Basic Ubuntu Desktop with GUI and VNC access + + + + +```typescript template.ts expandable +import { Template, waitForPort } from 'e2b' + +export const template = Template() + .fromUbuntuImage('22.04') + // Desktop environment and system utilities + .runCmd([ + 'yes | unminimize', + 'apt-get update', + 'apt-get install -y \ + xserver-xorg \ + xorg \ + x11-xserver-utils \ + xvfb \ + x11-utils \ + xauth \ + xfce4 \ + xfce4-goodies \ + util-linux \ + sudo \ + curl \ + git \ + wget \ + python3-pip \ + xdotool \ + scrot \ + ffmpeg \ + x11vnc \ + net-tools \ + netcat \ + x11-apps \ + libreoffice \ + xpdf \ + gedit \ + xpaint \ + tint2 \ + galculator \ + pcmanfm', + 'apt-get clean', + 'rm -rf /var/lib/apt/lists/*', + ]) + // Streaming server setup + .runCmd([ + 'git clone --branch e2b-desktop https://github.com/e2b-dev/noVNC.git /opt/noVNC', + 'ln -s /opt/noVNC/vnc.html /opt/noVNC/index.html', + 'git clone --branch v0.12.0 https://github.com/novnc/websockify /opt/noVNC/utils/websockify', + ]) + // Set default terminal + .runCmd( + 'ln -sf /usr/bin/xfce4-terminal.wrapper /etc/alternatives/x-terminal-emulator' + ) + .copy('start_command.sh', '/start_command.sh') + .runCmd('chmod +x /start_command.sh') + .setStartCmd('/start_command.sh', waitForPort(6080)) + +``` + +```python template.py expandable +from e2b import Template, wait_for_port + +template = ( + Template() + .from_image("ubuntu:22.04") + # Initial system setup and packages + # We are not using .apt_install() here because some packages have interactive prompts (keyboard layout setup, etc.) + .run_cmd( + [ + "yes | unminimize", + "apt-get update", + "apt-get install -y \ + xserver-xorg \ + x11-xserver-utils \ + xvfb \ + x11-utils \ + xauth \ + xfce4 \ + xfce4-goodies \ + util-linux \ + sudo \ + curl \ + git \ + wget \ + python3-pip \ + xdotool \ + scrot \ + ffmpeg \ + x11vnc \ + net-tools \ + netcat \ + x11-apps \ + libreoffice \ + xpdf \ + gedit \ + xpaint \ + tint2 \ + galculator \ + pcmanfm", + "apt-get clean", + "rm -rf /var/lib/apt/lists/*", + ] + ) + # Setup NoVNC and websockify + .run_cmd( + [ + "git clone --branch e2b-desktop https://github.com/e2b-dev/noVNC.git /opt/noVNC", + "ln -s /opt/noVNC/vnc.html /opt/noVNC/index.html", + "git clone --branch v0.12.0 https://github.com/novnc/websockify /opt/noVNC/utils/websockify", + ] + ) + # Set default terminal + .run_cmd( + "ln -sf /usr/bin/xfce4-terminal.wrapper /etc/alternatives/x-terminal-emulator" + ) + # Copy the start command + .copy("start_command.sh", "/start_command.sh") + .run_cmd("chmod +x /start_command.sh") + # Set start command to launch the desktop environment + .set_start_cmd("/start_command.sh", wait_for_port(6080)) +) +``` + + + + +```bash start_command.sh +#!/bin/bash + +# Set display +export DISPLAY=${DISPLAY:-:0} + +# Start Xvfb +Xvfb $DISPLAY -ac -screen 0 1024x768x24 -nolisten tcp & +sleep 2 + +# Start XFCE session +startxfce4 & +sleep 5 + +# Start VNC server +x11vnc -bg -display $DISPLAY -forever -wait 50 -shared -rfbport 5900 -nopw \ + -noxdamage -noxfixes -nowf -noscr -ping 1 -repeat -speeds lan & +sleep 2 + +# Start noVNC server +cd /opt/noVNC/utils && ./novnc_proxy --vnc localhost:5900 --listen 6080 --web /opt/noVNC --heartbeat 30 & +sleep 2 +``` + + + + +```typescript build.ts +import { Template } from 'e2b' +import { template as desktopTemplate } from './template' + +await Template.build(desktopTemplate, { + alias: 'desktop', + cpuCount: 8, + memoryMB: 8192, + onBuildLogs: (logEntry) => console.log(logEntry.toString()), +}) +``` + +```python build.py +from e2b import Template +from .template import template as desktopTemplate + +Template.build(desktopTemplate, + alias="desktop", + cpu_count=8, + memory_mb=8192, + on_build_logs=lambda log_entry: print(log_entry), +) +``` + + + +## Claude Code + +Claude Code Agent in a Sandbox + + + +```typescript template.ts +import { Template } from 'e2b' + +export const template = Template() + .fromNodeImage('24') + .aptInstall(['curl', 'git', 'ripgrep']) + // Claude Code will be available globally as "claude" + .npmInstall('-g @anthropic-ai/claude-code@latest') + +``` + +```python template.py +from e2b import Template + +template = ( + Template() + .from_node_image("24") + .apt_install(["curl", "git", "ripgrep"]) + # Claude Code will be available globally as "claude" + .npm_install("-g @anthropic-ai/claude-code@latest") +) +``` + + + + + + +```typescript build.ts +import { Template } from 'e2b' +import { template as claudeCodeTemplate } from './template' + +Template.build(claudeCodeTemplate, { + alias: 'claude-code', + cpuCount: 1, + memoryMB: 1024, + onBuildLogs: (logEntry) => console.log(logEntry.toString()), +}) +``` + +```python build.py +from e2b import Template +from .template import template as claudeCodeTemplate + +Template.build(claudeCodeTemplate, + alias="claude-code", + cpu_count=1, + memory_mb=1024, + on_build_logs=lambda log_entry: print(log_entry), +) +``` + + + + + +```typescript sandbox.ts + +import { Sandbox } from 'e2b' + +const sbx = await Sandbox.create('claude-code', { + envs: { + ANTHROPIC_API_KEY: '', + }, +}) + +console.log('Sandbox created', sbx.sandboxId) + +// Print help for Claude Code +// const result = await sbx.commands.run('claude --help') +// console.log(result.stdout) + +// Run a prompt with Claude Code +const result = await sbx.commands.run( + `echo 'Create a hello world index.html' | claude -p --dangerously-skip-permissions`, + { timeoutMs: 0 } +) + +console.log(result.stdout) + +sbx.kill() +``` + +```python sandbox.py +from e2b import Sandbox + +sbx = Sandbox( + 'claude-code', + envs={ + 'ANTHROPIC_API_KEY': '', + }, +) +print("Sandbox created", sbx.sandbox_id) + +# Print help for Claude Code +# result = sbx.commands.run('claude --help') +# print(result.stdout) + +# Run a prompt with Claude Code +result = sbx.commands.run( + "echo 'Create a hello world index.html' | claude -p --dangerously-skip-permissions", + timeout=0, +) +print(result.stdout) + +sbx.kill() +``` + + diff --git a/template/how-it-works.mdx b/template/how-it-works.mdx new file mode 100644 index 0000000..68aca26 --- /dev/null +++ b/template/how-it-works.mdx @@ -0,0 +1,28 @@ +--- +title: "How It Works" +description: "How the template building process works" +icon: "file-lines" +--- + +## General overview +Every time you are building a sandbox template, we create a container based on the definition. +We extract the container's filesystem, do provisioning and configuration (e.g. installing required dependencies), run layers commands and start a sandbox. + +Then, these steps happen: + 1. We take the running sandbox. + 2. (Only if you specified the [start command](/template/customization/start-ready-command#start-command), otherwise this step is skipped) Execute the start command. + 3. Wait for readiness (by default 20 seconds if start command is specified, otherwise immediately ready). Readiness check can be configured using [ready command](/template/customization/start-ready-command#ready-command). + 4. Snapshot the sandbox and make it ready for you to spawn it with the SDK. + +We call this sandbox snapshot a _sandbox template_. + + + Snapshots are saved running sandboxes. We serialize and save the whole sandbox's filesystem together with all the + running processes in a way that can be loaded later. + + This allows us to load the sandbox in a few hundred milliseconds any time later with all the processes already running + and the filesystem exactly as it was. + + +## Caching +TODO diff --git a/template/migration.mdx b/template/migration.mdx new file mode 100644 index 0000000..6376ffa --- /dev/null +++ b/template/migration.mdx @@ -0,0 +1,35 @@ +--- +title: "Migration" +description: "How to migrate from the legacy template definition" +icon: "forward-fast" +--- + +To migrate the existing template definition to the new format, follow these steps: +1) Install the latest version of the [E2B CLI](https://e2b.dev/docs/cli) +2) Navigate to the folder of your existing template definition (where you have `e2b.toml` and `e2b.Dockerfile` files). +3) Run the migration command: +```bash +e2b template migrate +``` +4) Follow the prompts to complete the migration process. +5) Done + +## Generated Output +The migration command generates three files (based on the selected language). + + + + +```typescript +template.ts - Template definition using the SDK +build.dev.ts - Development build script +build.prod.ts - Production build script +``` + +```python +template.py - Template definition using the SDK +build_dev.py - Development build script +build_prod.py - Production build script +``` + + diff --git a/template/quickstart.mdx b/template/quickstart.mdx new file mode 100644 index 0000000..2ae5c7e --- /dev/null +++ b/template/quickstart.mdx @@ -0,0 +1,194 @@ +--- +title: "Quickstart" +description: "Start with custom sandbox templates" +icon: "rocket" +--- + + +### Install the packages + +Requires the E2B version at least 2.1.0 + + + + +```typescript Terminal +npm install e2b dotenv +``` + +```python Terminal +pip install e2b dotenv +``` + + + +Create the `.env` file + +```bash +E2B_API_KEY=e2b_*** +``` + +### Create a new template file +Create a template file with the following name and content + + + +```typescript template.ts +import { Template, waitForTimeout } from "e2b"; + +export const template = Template() + .fromImage("ubuntu:22.04") + .setEnvs({ + HELLO: "Hello, World!", + }) + .setStartCmd("echo $HELLO", waitForTimeout(5_000)); +``` + +```python template.py +from e2b import Template, wait_for_timeout + +template = ( + Template() + .from_image("ubuntu:22.04") + .set_envs( + { + "HELLO": "Hello, World!", + } + ) + .set_start_cmd("echo $HELLO", wait_for_timeout(5_000))) +``` + + + + +### Create a development build script + + + +```typescript build.dev.ts +import "dotenv/config"; +import { template } from "./template"; +import { Template } from "e2b"; + +Template.build(template, { + alias: "template-tag-dev", + cpuCount: 1, + memoryMB: 1024, + onBuildLogs: (logEntry) => console.log(logEntry.toString()), +}); +``` + +```python build_dev.py +from dotenv import load_dotenv +from e2b import Template +from template import template + +load_dotenv() + +Template.build( + template, + alias="template-tag-dev", + cpu_count=1, + memory_mb=1024, + on_build_logs=lambda log_entry: print(log_entry), +) +``` + + + +Build the development template + + + +```typescript Terminal +npx tsx build.dev.ts +``` + +```python Terminal +python build_dev.py +``` + + + +### Create a production build script + + + +```typescript build.prod.ts +import "dotenv/config"; +import { template } from "./template"; +import { Template } from "e2b"; + +Template.build(template, { + alias: "template-tag", + cpuCount: 1, + memoryMB: 1024, + onBuildLogs: (logEntry) => console.log(logEntry.toString()), +}); +``` + +```python build_prod.py +from dotenv import load_dotenv +from e2b import Template +from template import template + +load_dotenv() + +Template.build( + template, + alias="template-tag", + cpu_count=1, + memory_mb=1024, + on_build_logs=lambda log_entry: print(log_entry), +) +``` + + + +Build the production template + + + +```typescript Terminal +npx tsx build.prod.ts +``` + +```python Terminal +python build_prod.py +``` + + + +### Create a new Sandbox from the Template + + + +```typescript +import "dotenv/config"; +import { Sandbox } from "e2b"; + +// Create a Sandbox from development template +const sandbox = await Sandbox.create("template-tag-dev"); + +// Create a Sandbox from production template +const sandbox = await Sandbox.create("template-tag"); +``` + +```python +from dotenv import load_dotenv +from e2b import Sandbox + +load_dotenv() + +# Create a new Sandbox from the development template +sbx = Sandbox(template="template-tag-dev") + +# Create a new Sandbox from the production template +sbx = Sandbox(template="template-tag") +``` + + + + +The template alias is the identifier that can be used to create a new Sandbox. + From f027b26dd752da44cd52936c343278f2eee0e438 Mon Sep 17 00:00:00 2001 From: Jakub Dobry Date: Tue, 16 Sep 2025 13:42:56 +0200 Subject: [PATCH 2/7] improve the migration guide --- template/migration.mdx | 92 +++++++++++++++++++++++++++++++++++++----- 1 file changed, 83 insertions(+), 9 deletions(-) diff --git a/template/migration.mdx b/template/migration.mdx index 6376ffa..f566d1c 100644 --- a/template/migration.mdx +++ b/template/migration.mdx @@ -4,17 +4,36 @@ description: "How to migrate from the legacy template definition" icon: "forward-fast" --- +We've made ready for you three ways how to migrate existing template to the new definition format. + +- Using the migration command (recommended) +- Using the `fromDockerfile()` method to parse existing Dockerfile +- Building the Docker image manually and using `fromImage()` method + +## Migration Command (Recommended) + To migrate the existing template definition to the new format, follow these steps: -1) Install the latest version of the [E2B CLI](https://e2b.dev/docs/cli) -2) Navigate to the folder of your existing template definition (where you have `e2b.toml` and `e2b.Dockerfile` files). -3) Run the migration command: -```bash -e2b template migrate -``` -4) Follow the prompts to complete the migration process. -5) Done -## Generated Output + + + Install the latest version of the [E2B CLI](https://e2b.dev/docs/cli) + + + Navigate to the folder of your existing template definition (where you have `e2b.toml` and `e2b.Dockerfile` files). + + + ```bash + e2b template migrate + ``` + + + Follow the prompts to complete the migration process. + + + + + +### Generated Output The migration command generates three files (based on the selected language). @@ -33,3 +52,58 @@ build_prod.py - Production build script ``` + + +## Using `fromDockerfile()` Method + +If you want to keep using Dockerfile for your template, you can use the `fromDockerfile()` method. +We'll automatically parse the Dockerfile for you and build the template based on it. +You can find more at [Base Image](/template/customization/base-image#parsing-existing-dockerfiles). + + + +```typescript template.ts +import { Template } from "e2b"; + +const template = Template() + .fromDockerfile(dockerfileContent); +``` +```python template.py +from e2b import Template + +template = ( + Template() + .from_dockerfile(dockerfile_content) +) +``` + + + +After the template definition, you can create the build scripts as described in the [Quickstart](/template/quickstart#create-a-development-build-script) section. + + +## Using `fromImage()` Method + +If you already have a Docker image built, or you want to keep building the Docker image yourself you can use the `fromImage()` method. +Simply build the Docker image for the `linux/amd64` platform, push it to a registry of your choice and reference the image tag in the `fromImage()` method. +You can also specify credentials for private registries as described in the [Base Image](/template/customization/base-image#custom-base-image) section. + + + + +```typescript template.ts +import { Template } from "e2b"; + +const template = Template() + .fromImage("image-tag"); +``` +```python template.py +from e2b import Template + +template = ( + Template() + .from_image("image-tag") +) +``` + + From cddb148e30d365904e9c5d4145c0753db6d3aaa2 Mon Sep 17 00:00:00 2001 From: Jakub Dobry Date: Tue, 16 Sep 2025 14:00:36 +0200 Subject: [PATCH 3/7] add caching explanation --- template/how-it-works.mdx | 21 ++++++++++++++++++++- 1 file changed, 20 insertions(+), 1 deletion(-) diff --git a/template/how-it-works.mdx b/template/how-it-works.mdx index 68aca26..b1d7c70 100644 --- a/template/how-it-works.mdx +++ b/template/how-it-works.mdx @@ -25,4 +25,23 @@ We call this sandbox snapshot a _sandbox template_. ## Caching -TODO +The caching concept is similar to [Docker's layer caching](https://docs.docker.com/build/cache/). For each layer command (.copy(), .runCmd(), .setEnvs(), etc.), we create a new layer on top of the existing. +Each layer is cached based on the command and its inputs (e.g., files copied, command executed, environment variables set). +If a layer command is unchanged and its inputs are the same as in any previous build, we reuse the cached layer instead of rebuilding it. + +This significantly speeds up the build process, especially for large templates with many layers. +The cache is scoped to the team, so even if you have multiple templates, they can share the same cache if they have identical layers. + +### Files Caching +When using the `.copy()` command, we cache the files based on their content. If the files haven't changed since the last build, we reuse them from the files cache. + +We differ from Docker here. Because we build the template on our infrastructure, we use improved caching on files level. +Even if you invalidate the layer before `.copy()` (e.g., by changing ENV variables), we'll reuse the already uploaded files. +The `copy()` command will still be re-executed, but the files for the layer will be reused from the files cache, no need to upload them from your computer again. + +### Use Case for Caching +You can leverage caching to create templates with multiple variants (e.g., different RAM or CPU) while reusing the common layers. +When building the template, just change the template alias to a specific RAM/CPU configuration (e.g., `my-template-2cpu-2gb`, `my-template-1cpu-4gb`), keep the rest of the template definition the same, and the build process will reuse the cached layers. + +### Optimize Build Times +To optimize build times, place frequently changing commands (e.g., copying source code) towards the end of your template definition. This way, earlier layers can be cached and reused more often. From 67b0e6437ee67f37656e3670dd0b168adfeaf0c2 Mon Sep 17 00:00:00 2001 From: Jakub Dobry Date: Tue, 16 Sep 2025 14:45:55 +0200 Subject: [PATCH 4/7] add cli init guide --- template/quickstart.mdx | 33 ++++++++++++++++++++++++++++++++- 1 file changed, 32 insertions(+), 1 deletion(-) diff --git a/template/quickstart.mdx b/template/quickstart.mdx index 2ae5c7e..3c6000f 100644 --- a/template/quickstart.mdx +++ b/template/quickstart.mdx @@ -4,6 +4,37 @@ description: "Start with custom sandbox templates" icon: "rocket" --- +E2B templates allow you to define custom sandboxes. +You can define the base image, environment variables, files to copy, commands to run, and +a start command that will be already running when you spawn the sandbox. +This way, you can have fully configured sandboxes with running processes ready to use with zero wait time for your users. + +There are two ways how you can start creating a new template: +- using the CLI +- manually using the SDK + +## CLI + +You can use the E2B CLI to create a new template. + + + + Install the latest version of the [E2B CLI](https://e2b.dev/docs/cli) + + + ```bash + e2b template init + ``` + + + Follow the prompts to create a new template. + + + Check the generated `README.md` file to see how to build and use your new template. + + + +## Manual ### Install the packages @@ -159,7 +190,7 @@ python build_prod.py -### Create a new Sandbox from the Template +## Create a new Sandbox from the Template From 0b171bd1e3ac3835e588d95b880637f3098c9b31 Mon Sep 17 00:00:00 2001 From: Jakub Dobry Date: Tue, 16 Sep 2025 15:20:05 +0200 Subject: [PATCH 5/7] remove the start command logs outdated info --- template/customization/logging.mdx | 4 ++ .../customization/start-ready-command.mdx | 49 ------------------- 2 files changed, 4 insertions(+), 49 deletions(-) diff --git a/template/customization/logging.mdx b/template/customization/logging.mdx index 421d250..c78ca65 100644 --- a/template/customization/logging.mdx +++ b/template/customization/logging.mdx @@ -4,6 +4,10 @@ description: "How to view logs from the template build" icon: "eye" --- +You can retrieve the build logs using the SDK. + +## SDK + The `onBuildLogs`/`on_build_logs` callback receives structured `LogEntry` objects with the following properties: diff --git a/template/customization/start-ready-command.mdx b/template/customization/start-ready-command.mdx index 4568a9f..2d459a3 100644 --- a/template/customization/start-ready-command.mdx +++ b/template/customization/start-ready-command.mdx @@ -12,55 +12,6 @@ The idea behind the start command feature is to lower the wait times for your us You can see how it works [here](/template/how-it-works). -### Logs -You can retrieve the start command's logs using the SDK during runtime. - - -These logs are the logs from the start command during the build phase. - - - -```js {{ language: 'js' }} -import { Sandbox } from 'e2b' - -// Spawn your custom sandbox -const sandbox = await Sandbox.create({ - id: 'my-agent-sandbox', - // If you specify onStderr and onStdout handlers when spawning the sandbox - // you will see logs from the start command. - onStderr: output => console.log("stderr", output.line), // $HighlightLine - onStdout: output => console.log("stdout", output.line), // $HighlightLine -}) - -// Close sandbox once done -await sandbox.close() -``` - -```python {{ language: 'python' }} -from e2b import Sandbox - -# Spawn your custom sandbox -sandbox = Sandbox.create( - id="my-agent-sandbox", - # If you specify on_stderr and on_stdout handlers when spawning the sandbox - # you will see logs from the start command. - on_stderr=lambda output: print("stderr", output.line), # $HighlightLine - on_stdout=lambda output: print("stdout", output.line), # $HighlightLine -) - -# Close sandbox once done -sandbox.kill() -``` - - -Or you can use the CLI: - - -```bash {{ language: 'bash' }} -e2b sandbox logs -``` - - ## Ready command The ready command allows you to specify a command that will determine **template sandbox** readiness before a [snapshot](/template/how-it-works) is created. It is executed in an infinite loop until it returns a successful **exit code 0**. From 9504919719ccfc56a67d2b64c7165453cd7cb61d Mon Sep 17 00:00:00 2001 From: Jakub Dobry Date: Tue, 16 Sep 2025 17:58:00 +0200 Subject: [PATCH 6/7] add private registries access docs --- template/customization/base-image.mdx | 92 +++++++++++++++++++++++++-- 1 file changed, 88 insertions(+), 4 deletions(-) diff --git a/template/customization/base-image.mdx b/template/customization/base-image.mdx index f6eea7f..ec7ccef 100644 --- a/template/customization/base-image.mdx +++ b/template/customization/base-image.mdx @@ -4,7 +4,7 @@ description: "How to define a base image for your template" icon: "1" --- -### Creating template +## Creating template When creating a template, you can specify options: @@ -28,7 +28,7 @@ template = Template( **File ignoring**: The SDK automatically reads `.dockerignore` files and combines them with your `ignoreFilePaths`. Files matching these patterns are excluded from uploads and hash calculations. -### Defining base image +## Defining base image Choose from predefined base images or use custom ones: @@ -93,7 +93,7 @@ template.from_dockerfile("FROM ubuntu:22.04\nRUN apt-get update") You can only call base image methods once per template. Subsequent calls will throw an error. -### Parsing existing Dockerfiles +## Parsing existing Dockerfiles Convert existing Dockerfiles to template format using `fromDockerfile()`: @@ -134,7 +134,7 @@ template = ( -#### Dockerfile instructions support +### Dockerfile instructions support | Instruction | Supported | Behavior | | :--- | :----: | :--- | @@ -151,3 +151,87 @@ template = ( Multi-stage Dockerfiles are not supported. + +## Login to private registries +If your base image is hosted in a private registry, you can provide credentials using the following helpers: +- General registry +- GCP Artifact Registry +- AWS ECR + +### General Registry + + + +```typescript +Template().fromRegistry('ubuntu:22.04', { + username: 'user', + password: 'pass', +}) +``` + +```python +Template().from_registry( + image="ubuntu:22.04", + username="user", + password="pass", +) +``` + + + + +### GCP Artifact Registry + + + +```typescript +// From file path +Template().fromGCPRegistry('ubuntu:22.04', { + serviceAccountJSON: './service_account.json', +}) + +// From object +Template().fromGCPRegistry('ubuntu:22.04', { + serviceAccountJSON: { project_id: '123', private_key_id: '456' }, +}) +``` + +```python +# From file path +Template().from_gcp_registry( + image="ubuntu:22.04", + service_account_json="./service_account.json", +) + +# From object +Template().from_gcp_registry( + image="ubuntu:22.04", + service_account_json={"project_id": "123", "private_key_id": "456"}, +) +``` + + + + +### AWS ECR + + + +```typescript +Template().fromAWSRegistry('ubuntu:22.04', { + accessKeyId: '123', + secretAccessKey: '456', + region: 'us-west-1', +}) +``` + +```python +Template().from_aws_registry( + image="ubuntu:22.04", + access_key_id="123", + secret_access_key="456", + region="us-west-1", +) +``` + + From 49bd21f1cb3e096c424f983682037b84999a18d3 Mon Sep 17 00:00:00 2001 From: Jakub Dobry Date: Thu, 18 Sep 2025 11:10:19 +0200 Subject: [PATCH 7/7] add E2B branding --- docs.json | 38 +++++--------------------------------- favicon.png | Bin 0 -> 90494 bytes favicon.svg | 19 ------------------- logo/dark.svg | 25 +++++-------------------- logo/light.svg | 25 +++++-------------------- 5 files changed, 15 insertions(+), 92 deletions(-) create mode 100644 favicon.png delete mode 100644 favicon.svg diff --git a/docs.json b/docs.json index c5e20e4..57186d5 100644 --- a/docs.json +++ b/docs.json @@ -3,32 +3,17 @@ "theme": "mint", "name": "E2B Documentation", "colors": { - "primary": "#16A34A", - "light": "#07C983", - "dark": "#15803D" + "primary": "#FF8800", + "light": "#FF8800", + "dark": "#E57B00" }, - "favicon": "/favicon.svg", + "favicon": "/favicon.png", "navigation": { "anchors": [ { "anchor": "Documentation", "icon": "book-open", "groups": [ - { - "group": "Getting Started", - "pages": ["What's E2B?", "Quickstart", "Getting API Key"] - }, - { - "group": "Sandbox", - "pages": [ - "Sandbox lifecycle", - "Environment variables", - "Filesystem", - "Commands", - "Reconnect", - "Internet access" - ] - }, { "group": "Custom sandbox", "pages": [ @@ -50,21 +35,8 @@ "template/examples", "template/migration" ] - }, - { - "group": "Premade sandboxes", - "pages": ["Base", "Code interpreter", "Desktop"] - }, - { - "group": "Deploy E2B", - "pages": ["deployment/byoc", "deployment/self-hosting"] } ] - }, - { - "anchor": "SDK Reference", - "icon": "square-terminal", - "href": "https://external-link.com/blog" } ] }, @@ -76,7 +48,7 @@ "primary": { "type": "button", "label": "Dashboard", - "href": "https://dashboard.mintlify.com" + "href": "https://e2b.dev/dashboard" } }, "contextual": { diff --git a/favicon.png b/favicon.png new file mode 100644 index 0000000000000000000000000000000000000000..c76c772b371bfa1d3cb35c858e9031cf8a354c59 GIT binary patch literal 90494 zcmXtf1yq#H_wchzNGV;ClF}>PA|*(vC>=|SEFs-2N=S=Hmy*&A(yJ(llz_m}yn=+3 zbmKSc@Bev@$K#!6?%b}Kjk>RU_bSPC5(t8>YHFxHgdjW&?k^D`fSis~WP*Q)-876n zAc&3|_ZO!5kn0Zs!aN?{RfZ}Dnb*L7@Ez{x+<~B)1k!UW0tjYBt*LtFkuPlHg1DYp z(?2cpa&l>p(!mL{tzbH2)`C27e5WDF-n;Zlg^HfW?wU+Jy3x_JHX&}hr$?0A6mBx- z85oFE4`{_OSA67O0Mqs`q7Hk6afUK;fDjJVk6V>qZEo$914U!h^0$%NeV$q3I9Hrm-cILmrG)A()D(L zt5^#=KTu3DN`XPpAskKyL9Ljm@)Wb9tgoB()$on5<3#^0R75R^{{BZL^}T`tX9%~DK!6V1^F!{LqbValdp4USur6pPAl zEfB>+u?l>=`%tS!pdJVj4&7;Ddo@)E_umYI7LTPU0)ktI&5Q+_sCK(FW$pCV>E< zO_y4@bJ(%Q%~ArWS_-!~>%o5GQvf@Jkcj8{idY+gAUPZnSVh^2^k;3*+jP=@FgzUW znsCL5(#u^q=9HOu*a|{dgo1NXgbFD~_i@n4bSOVn&E=e7KVF;qYosO^JN{GH?Wp`|MLzE0!02YM&&E5_n2;#%U z9f6ZEKs>}Fq>%oyhH{4ZSOE?B?!nL>iE}DA znp)DdSQr~^A`%E7WC3o6diiRL#&#$$W6d;?6uD2nRuIDtz(#D;i!bh4uPh+6j+K7? zEC8cF0&QTvH{bM%-qX49g%LuU_7}zz%~R%mf)Gf+Ap^&wXF!;2cOTvj-zJ7I7$rco z1~U;s1&AJ>%wCe<{R6$-HX3ekG^!*W2FN?yxm3epNC=Sf-O!BNq5BXHkwrFB&=R6q z!Es9S(iHqMcu*{iUjt8R8z6j3{^7~?f7a>5z$c@c5mg9iA0M!I7?u6$Yy74H%}5pu z@Jn5i|FPgM9%c?l0vj`t;~)g-cSrx}1Ej$qZ=6rHK5q_yLF{(IUaH4A5VV04Y2(!~ zupLRe_hom)+D}I#feeL9bt{0dUCe9*~!`P~^je9R*x4 zn!QEO56I;M2o?&M@3HJ;1O70VX`~!v5HB!Ww3iIcXL=yU9y1Cn$cP%yYVhplOA!d# z&uwP^1XaTUq(%DQHxd87S%tu^H!61m0YAt61eAnmoS2v+pC7{^%<(_OSAm+DiT3^h z(!ogxKMEvz&7B>GRy*Ou+Ap|f<;&HM59t0gs%&Ua=KfSghBE`%&M+POHQ>mw(n zv;fXLCABv}r5dWb5{b_^v>-Hz|dH|_`>zx#r9T}Un;8zjy*TSB4fR!`*4x=1uRR-jJ1UUlZ zmL`;9NZ*HdCm0v02T(QgG|S|K3^WBwcw~4?JMFv&3|wH-D*563a@UvL%&?OeFn@Bs z@6g4v(uX<_x)C(XF~0~(oID{V@*4!#-{$sn703uZD(uCg_@ z?2(hM0ZWBc!t0-)bCgNMl|q1IMM!Y6NALhV_dxs)h@g3bzVOg}y3?>W_!a01^8wJ< zqiiCsB*IQ`9ocC{T_gbqi3@(n({$nUcl6WDM<@WqIV`zYNsR3|aY@e=zzgQM#@N!} zxkJpaVQW7Qs9GN=e|9n2?7|x?qWP2)1rs;)a8CB7+ z#snRo)1!j;(?Q$zwWf_V*oY>tYmzBjCkc$+6P-fL2Km=01KkNwt(|rR@R?T=V>^)!= zLV?%-4j}@E3|@Nxj0nQ=h~2nOR!#X5!pmZntJ0#Bvg{A}iSyzgroc({O z3kpF{3(*iEl;SS#{+y=o^C1ea1m7c>rHLC8Zu3D(B;x2Fd_&}6$~ad+SS%~w6GzK) zL!;e;n`if5;UvW%B~}u$H$#IaRv{7BrcK=qG}Z7U1j=?qhU~Q&{+_>cyVK}W1eV57 zpwvZ^PRuui!{m&^q)qYgt<_U3|4@NE9x$CB>6#artM?%ue7^4pZVQ@H92An?aOEgf z?J599ScE~pv!a7*YUcXlsT>^+1&_s920GDK`#I^qjX z&KRCF(#7Xiwg^Io?yw5$uQYc75X!XTIdCm=f+MJKME6>vI>jmiJAn|1%jb$?KV23hgM9^p=6;PiN>ERIX8rx@*j zwu8PUM$g6I55dXKx^+A}|Ho!OR{V*;#~ye!ZyF&n$iT~AQ@-8B`5Dxma53Nza%N5s zVhHUMEWJwxCxAj}bQ2kOi!`5Szks?Ft9JuH(Fmkf$}FCsf!LtIXYju2agGx<`j=9g z0E0IfoUC;IGwz4vSSAr{)k1IeNJzgLrPWGk4io#f##K=n1r@0`O|dEwP+@8MUc z?Rjuv5rPDJbmC;F(L%ua8hf>mV?Z_`7b}m@1g?=Kwa;4#X&H}>BL^PNKy(|gwD^Ue_0A-eil>ODfQSwUDr4Frk|cnmc&(LZB{raxYG*LO-(5n~unm|@aP6ZCz+$}(}G6GF;i=QBc- ze&-n_;4i#k$GFjzpU>g)CMXM#`52Eo&;P?gP5uw}6%9nzb$kY0y#HZ7!zYf=4~4ok z|7Q?y$=N@;SyLdTiT@{pePS*KU3@s%`tyH+RbspI+{&2(X>{d(e4mn0kvW0g{QpDF z0M|g27f_&GHY_=+{`oG(?L)0mJU%-foXp(JOpu(ePX?!7h~b)ELCS&+OhXBMjEk{{RaB zc)^ZA|DzToo<>R~??Rc81njJH`{OX|x5Z{{ zz7MwM+67!YPKp?8O7EWeOJ)-9Q=d)#Nrz#en$9R!VknmG?8;0v__OcT9DLDY91#?v zu_Bf{gu2ldXfG%zsAAzltW6k=)QMb=`2|YKeHtdA!1Lps5$7CvKaNyk^VcVV!qp+; zC;ftlVseU#bP$@=zs)V|L(qcLg7M+k>siUw8lYjaEihmI})j85!v`A6uPxMoKUIC;@^L zx-YryitlES#?paZ_KilYID1rBSy))$%A_XPf~~8E2uZrT#$>{vede>w$xH7X;#fL- z-?l$j7$Cx~2B!(#`gWE8|Fc8q&CGN_u@UKw)y!H!w{^%z(llHIH$ z&{#J*8Np;6Hf#OmXn7!MsK_T{2=tPA{RNjoS2^)vth|j=UqeAwgajTHYbG@82D}zG z!;&3lk)j{aC%@&-F< zz!PyG?fhREv+6nw`L;i7Em0i?mk-<`0m8?#OX903PS2z>s9TdsFR;K5i~ z#jG|!YlwC({AAKxtAB`@te$W)wJFsEUnL?#l7{dJ2}aqklA3xA4$_NKLui;y&w9tn za%Qd2hNp&i3rmrjEQ>)Po4jxJSf2IDQ0~ee41Eh>DVRz}8uIQcJ|N*|CGblGTvFoV z0lh(WI^Ej7S!Zz2I&DMK1q-OzD8=609Dl2Xj(oxLL;Z^b#6ZxRMw;T7sM}LitnmB! z3FxC#neSbgvJgUWd9sbFFr0d+yl)ZyP!HV(Zt5oL{a7{j83sa#x{!V>y@O#`xCB+@ z%r=Nl3^2)0$HzN1leC7FW{LUvoS|db_ZyA;w^xwNpsyu6qt9R=m#1G9QbnJ|CC^;} z(E{@ldq5*C(((0sx!2@D1IN|tkUC-K>=g(;xVo@+eKONbPCeHiwmAl?5$?PPC4( z+N`WsEGK}^h}`rifb#8gDUm+sK}YZOuwS=3IIAUvSRv$RZ0Ay1{M)GlRCzHjG@5iUd{m-cUc8Pkms z|MFwHLoI}*;0_)}^#kAe<-7pE1=_(ok`QKfZT*pyek{E6^yzJfC0y^X{0i1`mtx`K zBLk>D$bzzeci)@nD27dOOYTlj4E-}SWdy5l0^;gOa5ZhNW)OtdMC!Y2dddZT(T(w3 z8{zibU5bj$?$8eS5uTm%EtnO8s6QG+1m8gxQ^4jFB5~Fewi@uXj8<8W)pujR;?Lu2 zBX40yYivkhB`GLse4F~izPUn(TM@6Oo))Y9Ze`91f7c(>@2LSH?xeB#_ON4Gzbv1E zju5H5@6}(@t^0BBXN<@p z8JguF`g2%aG9(6r(rykZo|TiOxB5iN34Hk;<9GF<6%Wke(ylwkAP9Zsu$HVi$IHWt zk4w!5>PHMF3m7h~u4+Vt2?a{n`uSwt4#~kC>}3HOX<`%zkC_g*@=!agM%zwIHIcdR zk*;}GVe6~)59o)QG{3>p>H*4Q{kKB91X2?)bY=0&|53P z#Sndqz#X+UfuOBvW27wTJ%_ZPuAs#}F)Y-9F(Me~LHry0cO{*DWA~q#6x3)3yy=Q> zZ5+J;gU~DAtYxUAB~;Nv*MN&dS0yj}%6FY=@+O=1nELAP%4{?gT^EOx@Jqfs;KLM| za2(z|mDlyA-ggF=fOFqE+@^sr#OcJ~i{~_}qhiz#b72t2hPb><0`|bpgiD|UATKYS_r{~9J< zKkMX;#N9eX$ruUpRt-vv7Fpms;R<~);;xqT-l!5n6BKvRxz)yevC!(S&B@V974F^H zsR8}$6!y6heMXPwZnLPf3$8J6<9KH*G|)nS+f8aD30$7K`x2Z_{80PdHUc;eCcT;G;D<)OJqh1; za$7hX7le_lSsRkPdi`w`))Ayu4IpBkc)C7X##=TC5Zgb!@St`CmgrC8vx_s7odMCy zO6psBHuMXvKpzgzYmyN($CYph74~34?|L1?Ml#9@gR&UA|9-l^&`JVTQ(m+E{9xf$ z0<3Y*3zS^YVAw5nC<4uL1y!t4oAB>E+X9==p6f708ZZ}F=zsN)MCJK2AReYgC3V@P zK_h}RKOi1S3}^`Pks5!p2_P&(zGvwzl0WY#fR|v2`YT9O7AGBYL640k5@WQY@r|`X zGoFz`)i9LoTBd6UAEeSXc%>gyujn|?DbU-h#tOj$Z-PvWQAeJOkkR5|kYu;EIvoLP zCM0%94# z`JErvKxDLXY=8dg2TSC^*lV;c60v-*3zH0Jjiz`RRT2u2rf- zj-UFR@8VU^Nte>0&3As6RdG-to>&BIN_2Ep>tCDO3t0M@dM@dA7!y*~wzH%6ZFuNH zN9MFFL?2TBY^F{@04}W9gi~7K2smnLZMM~?ZdgjLFfw^z!ZM`YUmo=P;JUE*b}g8N zlhK~}6lGr{1~+IOf7p_o=J&na58AIJALj&2$k99LV39lfa|!3%&3m(d3;S;$62lmX zheT2WM3LR>z)-EkvA0qUo=<#?cOF&lHP%&*=wfn3@)YKFJx!Ug`}u`1Cm2QzDqK|Z*9IK4Tds^|3bd_e z_(m#EQMDca{UUNw;l4+Hai{rWHbfUv$7nyj(#nfxw@Qi3>qK1FrMfV`BGh#bg(V^L zJ83>XzlHp}Rrdf1F1UP$Za2UDbD3n}yMD8(TYS#x^#m3EhbMCeqUV6p#J$eAZI0N8 z{4b(dk^NT$$M+e|NI5^oH`Ln*H-$6ZMun$&IvRC1cE;%UT%H8{N;WLL8&KgKwtIT8 zKI4X^I^0$SIg9bu_b(fyw>z)*1e}z0m|g2QJrWE%V$noOMIAPdWR3BZ(9l!0cl`O) znOlQF@RUPry%1w9blXgDY3<`p>_JwU%XxJS1?T4l^|XC=WBc5BEMLfWEX?Uey*j1E-AKr3SVAlB6DbNm?HLBa5pVnU z!NR+Em?Fgzy?Pk!eWrKV$78d0i;*Yqq@B|w?d4{gJ&N^%g+$u-A0E8KcV#`xUfyn4 zdzi3zvFU!m6jEh&J~D4nDBWY@n|$8#*y1^9LtNN}XNHGXFjLmCWSR34{YiM@v+sg; zMG+C#VU7Pq;lUUvn_TBBNvsZFLS5QT;zF#7ff|(MS8ZI~CdFsGkf$XBHh-_Rdak|3 zcuF7t7D*_OV(rO{|8GFE^32by)R}axddWW5_cUMnIcjO}D3DF98X3#n3*}=}Xcp3c ze5r!e!!L%Ne%U02S4)Oo?6`y|i3aWy%J$iW1HF437X!<+$9Tb~(!|=a`+q(^9V!^&fD1YIn(zEjQ{arXtbPm<=$*u^r zUD@_)G7FmDPL8qM{o-Zfp*Hbh+N@>w^?|u4lUm~FP1ofQ#>8}%(E2AsGrQlMX>cD< z-Y^oW+zZVi-X*2R3{XE^A!NBO>2DYEp_Of0*!=Wh!qVZ~ZKx)^>ec*!P3Kwho^e&l_CfmZ`J>P8-EDCfZpozSx~Kns)`mvG zU?^xw+ML&Y`)&yHNq7lz^zEi6;R^}=0+Ugz|4~aY%ELhNsh5<>n?`Trs{LU_I zr|az3n4zWJwS}u5DfOmBDpT^_PYCCCF5Lf&ZKw2EUeJy$ehlc4uM5{)su$R8wKZ?) zc;#&?JvGPGD)8TcOW85j*jPxP>)ZjPBVK(y$D<6wDr%>n6albNXblX&8TiKWXr)jYSJA71Va@ztl5hhgPr5#F z(5T|kS~<-eTNRm3$?I!0&0hf{ZCNj#7X#C35E@&S8K{3m;qgbp z(wM%=e_rZQg2D6D=n~UJ)0NCqh`lwgF=OsXd^YnEIIW=%T5$(*E*Nf za}&W6X{Cz;ZOr&qaNTaQ&32B*3y zidEL-yqOWSs}sf7ds<)3_L1&1Jg^XH6AJBD^B!GcNgU@86PD&JZ~kGgKqwtY~o0$l<3oV0#I|TYKND)(D;2X|*yWdl*uVzu(`6D-0 za7f{3CcPUnP0M&Hmu3I7l<(PAR(8S>$SWKz0h^ig0(By%@WjEj=c1zNNk0bj3|SJV zSKG5t%Z)l5b-@9n!yUo1H63Fv*S)UwWQJ@cx&JclXz<5}{EUC|p#n5>349xkP;x#lj#a+;vXU<9hlK5>JB)9KTrTIn z4!C`~2#09fbEry&Kw473?9rE4v*)lSm-zP z-zyKUQc*Ykw8ruE^+(O8iS@>wDBcqrTh8X+%>kBoqv}Rk8stts<#Nf9vUho{l|V-l zaFlEQt(#YYGX*roBwGo6wz*8~XBgeA?!8rXI3z38E}0;7-##WbF4mnW4QUoPz39j`rw59X#O5z%%-} zsDDg?isf0(Jzw(DUkX&km)>fgqh36kl->#Eive=uyaaha8$CXyuPxp?8E8mst5P#= zn&+OCJ!P^g$W}J5YAP85&G71yhQBoTLpB0m9-!muH`7h7eHErn_}(#bgzKw+z5~x1 z+E||Kmanr7Lgn!4&Ar)M`D?`}3IgL3%GnE^=2N}Srt6~tTWiJK0;ywt+69u7&AzRb z&Z%ntsYJF81=#mB-7@K8XJ4P*8td8OM{=7x^IUAlo<>agbR3;69UcXCLYRkxT0_xR z2M@sLRG$qd82u$rzSm*OkpVu1Dy3@rJKvE&Hv6UetX> z5|(Gh^AiOUA^P(16SegjyU|`1k|}DQaa5zW<~N+wUA$WRPKz5oC}+&x_!uu4c5Z3d zxR7>)J$cs1kd}S8N(~(Cl4#fxJvNh=6GyORLs^aoLl@Kl+&(w8rrX+)x}(fik7}<+7%#&!nf? ztgWUebw(WZ!_`odqj1zz%gXS7I+wR5ia9ndT(YV=cwQ&S(yOiLgv!Ny71<@N zrjw$JX&0NxWK#=@0o@@GNBPx~#EYV##mICEhdnG4E4af+bw;k>@hsX<<44K(yKxzI zY^@jQF$ZoM_Wh~~N?;BgFf<$r@_fwYKHytkUcb^vn>a|b@F-X=zvH!WZlhDvD4vbS z=DqWdbyuF!spf1*vBW#VJ>>f5 zPvuY^Pg%NQuJF-l>8aa3slgN5bCYfaOkX+=&*oRceL&^PRc2Q;yFKW2>BwKpL+rwz z=-kktDyE)eTIHheOTn&tS!c0xi6|BYh%$q$20f zCJ7I>f5i+1mzZ5#%$pHcv5ZbL25m%#dG}hZG=c^^@mHeV7&&Ecv5pqc#Z-MyZ{_PH zuTs^!o5Iv4iCbT5mX0Q-?>^4wuB$LHJScucx_#*YIx06=3k$*aW7r7q|LP`4muQqD zj$EiK^ImG>Jmr~r=zz_a36ejOH{3($w12*+(Vn|(bWM`;>Cln<`0-a2h}Ef&N1T31 z<>Y7_d{H>k(>JDeq_;QW_T}j7+0Wpf_Iio*7JTNfpcR#0*LONOW;q+_IlDVlHD-U9 z24cBlj$nx}%cdBbjcTahbvmJQJl_6=Oj0gHSrOOP9w~cbx62i zLeXH+H-B->##>`~Fe)FK+@l>SxwYG^hh(E1F933cp&!2wAun?f*F(L2tv z{&7x~MY~C%d=f{ec}~EVOmoQJ4ixoeY;MY9(d&If?S>YKa`T79a%$L1W7!Yq4elpS zokgHZ!#MSs8{8Lr9CNYEcq?YSc(Y>Iz9nS+ptjyIaf@g#T5#2Dt6n%;c>p+Q93e6$up`+G+u1)Z{hHp|Ip#}65G;qOQv^VgSt>>C5QLoUc#7H zdtgiToJPf7*$??ICQnI|nqkOKD+^T*M(u}(rG5qF~Mf)b}1gHnYB)`qY z7;l)OtB8|xVUp1myRBt1LNKL9#X}#wXTB&?gS-sfa{INk;{X}1v(BpZE zU$#!rASyF1?4CuV>2A5fDpCCd=i=6-KaQVd{rOq)GMle8Yq%V~E&vT*st#O&Hv>Dlhnp8p-Ij&X1sq<6?Ju)i~y_H%KUd7 z$^1w5$pam(V(!mdj=HC^<35EOMWW+gZCOe_E>5D(_J@6OQOWUMj?;Z3)vc9=_4BWt zMyY~(EsLMD_Q!=M+q}+<`EGn%w$98Q5LbRIx=D#KkP!*Up!UtBTmVV7qGnS@6Q)#J z^1jHe{~2=Wb2+zf-oxOeoi3prs$srHE49@623al^mSmK_D@}3=_pn}Xn5uS<{{u>c zsA*IFPW7K2$^A}=(>N1&t&?d{&UwIyT%UQPP@@Oy;D)Lt zP_|D~OVS~ITegtyV~=)1o*-*kN&b|!*#^C3KjGgWJm+oAbyuU!TAL4J?`00|^BKy> z@OBoJSr*Iia`yG;JMBoEc&E^oKCKuP&77R);xG@|4_~^i2U5faZ`vL`^2{tnp{9yv zH74fQI|yS?!}nd1_BsTr)PNJv1l5v*dn#`W?dL3InQQF?MV9&0bLj>Du*m z4YR~&$r4AQEyFL9jvYNn#B{MFy!`Yre3!Q+&SM zIG~YjnX6%}6|6QM!&mEAeYe8z(CkH)}{6UkS`36j02@H<~-5b&r-4(D3qP@6a2c?T#WiKl>6^y~54g4ZC zIQCjq=Vi+VxUgzneRZc(IQb_R)#OxzfKHPQ@se|$v2mYhQan^8MdZ5+xXlV zjp82B^hT3uhsM#B+4L6Y0-4oZ_v;z$Of{Ec?rB43I?ZXdB0U|s@TtM~dqxs2a&dW? zqOz6(oxoqbzgaBf3)>#emugpQ+rcnygStpoYq-|lpsFlq zIj^8uQp|mZYCit!ll5bl>3y%Fc7xph>p}hHTKTo=Q&iJajqAs?^50tbPvvUN8>_yK zc)TtMnLHZD@=jJ}9IgsZCro z*Yv7E-kqh!bE#BVD>y_mVOzE8<-D$b$!tvwm%#&?+O~wEi}#!b>Q#LTB86ftrYx4u zRcxju6R(>GOU{=c_K%&ZZDq}zdRq48Ch1mKd?Ic73!YK8yRkQLZpE6D{;?pG#e+sU zV5rxMUwK1vB${`!N7{vXGr!apeBk29UU&G6+LIVuoJAK5VxJ+q%TxWboW zUd8djPO>zMb!4f^yuONGm)87D6vfow^kYYC#j--=3u(jfg@z(|r*L!dy~^#2RlTnl zx#x`F@ajEity2Fj8xcV@bQqzNT3_;AI~VRIIhcF9^XRAh;ZO}2%&Vpp-)ucFL5tc1 zdpI9osarBylO5~mtxt97bZ2TXPm~i$MBQ_%oCStv^DW;jOuk*R`6ACbNilsXEqmHK zE8kLN^Pu8L`-z<9U;8Oebh`)F!5a-Zt5h&b1P`ME!W|Q#!T7kg!*{hUn|Ke9F}?KW zBcsb2sa#%~Z-QI3-g}<;x5grcsaH`;(zH*biqCgM9j1bws_C1?MfS`TQgZg`M~r$% zZe9dN*UIWvrjOrB{pxD?Rh@q5=`008bDAf`QsqAZbdDRloc4>k!ha5wooeA9g*zCd zSbY25n!e>>7geY^e`xbns{cg$4#g^pD}wS5)O@SP-WbmgY@DRW->Nmg&@32JQ`Qfy z7%z70;wY0#XV%}IE`95)%)K(suu`Bmd^NtlD(XjuS*{MVjNyd)CAb*Tn*VD9huRnJ zdw&)tIBtP3b2YnKcLdR+qs8w9D3OkLsao@@%)h*HUo?y9zY`n(M{?bLy1`ax){;x4 zoFyfFFjQboIO;>Ov%|_)o$3CAhWkIuQ}?AOb?qvBdRDC7EUBLrOlzLCMelbj-zdu; z_<7X4_tV^OH+_f%+J9bF%jqpa2xc3sq|koE6>`?EA3ugdm{Tm1hWEK^E_h5+EK_OO zXH+ZPq-grR#K!!M%S;Wp<$QF{bY0tBgHzyabh2mW*+`I%Q1pZ7ol>X9K|jH@glXYq zpE_G}Pa%>unzPDVoigb|@urmthI#?}L&VTN$r<^^_$ZAJEg0rQtF%5_Gn9}tW01DY zR@WQtfRC*Mr6ix#$6W-eqz^2#g1L9cKcq`6HPIRmFpnyDK1OZPY{%Xdj>AUV>en@3 zPCGo!Cd9v)rES<>8lC#8xu_(erpJ6ZD}HQ^@69+R3j951qlH#kB5U!yxiM1skbk&N zb|AR(z=y_*6Zm?PvdN`+3oBB2Uv(I8mVD-RALFmJd(<=1II?ITKg<2Rh(?pM#qrGX z@55%7&8qI>j3osH#fkSeG*1nCH}b!Xv*qQp1zT#m5H3kd>>OGZpE`PFiMmW^2zK|% z%54sx+vHM#)8#Z@%&C#=YiooMu5xR~;Jb-}R}?>5UzS~XfY&i^F4J{XOSsEQlzzt@ zbjZliB%-)PClwXE`JJ>T)(+Kb*ZM714N$G(64RSYQ~bM|-bLn44^sLMdb9OfD&HsM zw$kODWy=h`*Qv{!*UU@|)cR4(n|o1ib{erli9}zzTh;X2#cXiE19hOcsR$t|pyAsh zLE2J{7a8_;K0>-J$fRJ)+x)e|<7Q{CQ^y}oMcZbk{L!SSdlJI?ooC)f;EHiUvf>Q) zSRS_lSM+OpZ%UTlIHn=eC-E~fja(D&Q(YqS^4ILA^IkGZam-G1Ybai{T3B3OvZ(~a zP6yth(#?tffFCZ+Sr@C--UcteWP&O`$Ty3xX0=tkuJg)^EU7L^e4Ki(OzJ7i6xWHD zELF*`TEAI|ZYf&ZB$>$M#lTb|ZyGPjk?5y)H<#l#$Jaa(`{Rflw{uBqIusRuO>58$ zcu{R6m^K~_6c&~ZSp(1N-Q2#|1D>^9i%NGU{e!A8qk&e1fat4PgK|84WJhmQP?g!v zj(jcbmEX+x`Gndo^+0nLG?oABI z>AAz_OU4{BlUfeSdt^@wF|_HMkLo3oW!iNbMNV{nCNoYB^tL40PMa+%%1BlbYpawV3l(b=$IfSw5^W7-~S%4HK8zXl2%y z)@_+KA`K@m89vu@91s09{hJ73kl3dZtIi~Uw88I-$OxHc^VsQ>azOl)i}>C%njc>M zwOp&QZ<9%(NI8}Ao9;Uoj#ycpNvUbOR!zC)Ro622XH)a>k}+n}YqGsWfsD9p9+|wG0|THPN9%%BX1E%2B`WsY@vKV4%<@geCo_zWMGn)i+h7N6@bF40pBtTHmq4D4l7x zI_{`?lz2evaN#{1G-#qUdT`nusu#W`dpn8pyKUwwk5ZeXK)BqjZqrJcvcut6 z&!GC7xVH1)A_X|ZO;fEG!nShQR|lEkr+P~}i#?*51NhMI|6sU>PdEN7e8iKHmVWij zimG{JecwMR5ph)Sl)a{?>(sVJHK{Xg?B73gS&Vi4)!2OLm2Fy7k@fxe7lokZI~KF+$e_4gRVmca(&&&3Nlpyj4?P>7JGuIN0Xzx}!X zF4W}!xU8Ugl6l$Ifa5g?MN+R5PM9X@ZFYXLw_>M(d+z1FHN$X8Y{3z2pWe0>G;RHZ zYWk5u{>5uAEddFi0|^<6ddn6UH8zvYX0N_eE88`hHE++`(L5E{<`UzvCeQZyTfusF z`z#!<(g_j4C`WIsM-0<-J!I zU7NP=ZR={0p`Jsu+}6BZTk_XB%VAf$47$Kj|dAsk)#qH>Gcr4!f8+yAg zlnO46#6JIDDTEv$d-n9*PAs0JUx|ra##DoFQyka2`(m8oKIiqL-{W?%6$1Vy;=>PF z{zDzqe626!mPqd74%)gGCH#8RL<)~9<<~gFoY~kix0J}p&c`iBf$L`9WU-$NMJ`Uj zl`i7CWDa3_1@70>5GeCQt-g`n%8-peL1zmVE;=PWaqynt-p!0T{_Px7d6e4gF?^#e z4_{0nB5K|#E>eeS&A+Pbst*};e0t1>--mfmoLpM75KP>qngNsb8-Wv?iB+es&4yN; zsr#A|u21x3({EE<5HQeB*mcp=8lzsGf|~w4!^#hSsIR6A0+U2`729L|bVg&5=(3#k z3(uVb6u&3OTl0t5d$Y;0wmh5lr^$zoy(dfY!+fb)himfNGXX8_9G$L)rsg)D+%m-) zS!2`ww`X%~PYst&8C~VTb^NbS0heg-?)pQ$k)%PQ`{=(WeE1FxL($h)JtNl~e-}yW zqFVAg(~m}096b-XdR!FrriEk=dsX%8g6`QkRBm?-eW_o)FRe~5Wht%yiYNAJRwaZbozNXa%lRxl=~rRiRXT+ z#_9bfa_WW(i}j9EujZ9fg=`L%Laj{i%*i}cwKkopCbLJf?dlah)iY-`)t6%#`Ge5Je^ezV(0FUJ z(cL;r-Kbqpm|7+K`bC$$G>lX#ag1D*{pEQXxNSGsN?d3dJJu7s%5Y- zRD_Oud+l+sP$PQwPacM6Z$^;*P1 zzoB-X%`u^8snY&*U9GLtlc=e~V$H8nmi@%jK4@_5aI2YaN<2uGN%QauHQUt$TeEY& zdA~Krx{JnbcqlV!JW-8B&V}x5ULVV!Ddr9GCA&mbX(iGrmNm8SjVOTbVx9tGP+*FIT%VF5M%iH6 zL`7=P!E41#!NeN24QV9MIHG&ghsaG!LoKCmyVN;lBa>yQY~JZqzkK-eo1%C5&^MbF zoyrR3-NhtozX9_rqX$#DDEB#@`QY`sZ;z7yA4^x^&}93yQ85sUmJ(^{kPr}1WOPX9 zXi!>Wpv16{?q-D2J!%6+ilp>l3`R`4K|03Zd;GoMU+~<|eV;z(x=wT#|4Kz*g^*+8 zobi54keXoA%Kh6U8sGRLmQ)6N3fKVj4oSkNC&H0wRr=3a2A}WNyiD1JqX*TN-f$+1<-Bw9q05_DaX;i@v&yzg0nF;+tE< z*^1sZp_$44!9rDbBoKe35%9?9;$IPftMik~M@_Q-ev|JOylF3-Br?u==m+D|RIgr? zlh$+04b#K}D3|N7iUo&^B0t_LE9dPoH}@Au{ZV(lWy125&W2er+O+Gi00;z#W7cd9 zE|OG>UGY6f=bfC5}Mq{1~vIme!$~(pW}W5h!?4Qc|Jo= ztH}OkZmCR$&@@`Iu5aa@a!qSrP*tLM0;7S{X@9{r^==7fxL2ccMHvS_O--$|C+}yS zM7=HB>C8lKFH{O0ny2U?b1uWAZbvCvJxDzPZ%?V}o8JzuRx z$-KuU*G|1-KJ4u0!0jv@UrGW6pn^V-6g%+e=yq(x^6COkhL?7_PG9Qd zHhVL+dw@!AD?!$TsJPLtLcp%}-DZppKtRAjB5X2fe%FucYJdaz&5zbLODP{dS!+aE zpXDY(m1?PU!VP`N%4P?>H|y*y6Wrd|HLG~-`8j@i$2m}L;;-SkS)@l<$m|=M*X6whi$fhWnG$Jwl`L~xI4EJ^0n*EoMlXK5t~}9fib(<|xNOYE zRKO_Dr}ec2P9=IpJZ<>d`gWe{_sd^mGXS@9dcZ1P+R zk4ys!Li)dGk0Mm<1ou&XDr{ks2Y)iemT^7J?w^AkRWWhcWaDsLq5e$ofozHcnEItc z>54re!&7H?&?~+lqPiqPvu>V^X%J`>i9?Q@nWG`SyPl(>OK!Ipk2DFmCSX`AVQ+5+ zyLhs5v3`T^73@%w&(L*SBA$lP0clplIQ4R-qsQCsBJ9$D#IKD!Vu@4gdNyBS$Z3$Z zyYVRsvXRX6=nh#rTC6$S(=f+rlxl-GeobTnCqOSD4mUYvFH0L#fX)Sg`Iic3wln=8j8nXuJ36w(- z``^eC+VT8C7dL~7CR=mwH|z@>oGHx1SkhpO4T;`?{DEI`9jA(j8v{{JTrJ7LL9;H7 zk>Rh?3QQ9EIb8$HP=O0V!O~g&LvD;T>h8$h6%(;Qqi$`BDG50u<7MG=&|j79^M>pf z->kDUP!HQo*xF)(sozdqlbCmAr&k2v!g>>{JE?l#1q`8E_)NmDMG&0Ru+M_e+K~+A zz4OL%hqGH13!~YA`)fIL9#wz^3^FPH<_S5HHe!rSs@y=AUatJjk5q$d;(&XI@K&zv zI|=liEhR;WYoYWdY0=ImJ$pM@>t3E(7W`DZ-URH1O~c)G)7CfXPE*0_UJtB&0|+IN za5Kn<&D}2_3$F@HI%78*pSeNKHCWiuJFv01KYW*GeE=x|xy=2Q4^r0)X{=-}j(?DB ze(H{4VQ(d=6xlQ%2Zkor@xw2zYwS1i*@WJ7ky6lz{Nkbr4do%U%BEEX+K5vH#8hpck^5V1NXAKZj>C$f9oW#j8J2iCB44h-n zbkWUwHIP9>ki!DcbGo*xVdm$xlCI{?R>ZcYQtCXF=x$)M&ejqfey@(bZ1y`0duSN< zx=yZUvB7_+@g0AS>DW|uupGB6hfK@83Zw1MOvHg0eabtP+=Bec4H>bcv_DZ#Nc=xK z`T`6(Oe`#Y)Rj4{bzZK-w?nQ8JzCLLcbQ#b_audxH$1ED_RtgYYNNA4e818z>a>Jh zg-i;k)Zj09hbu~I;v%Q*2PL@|^Bs@j5KRt>dA89CHb&32XE!fXKj1ABbj7VN_0%p3 zzSd&J;~&y3iq1WiNZZnUR^dpyn^PiJsPtBIwDn2&)Y&b@$ub}3!9wAvBehXzb7qh{ zr9rNsQ9$$U(H{3X)2Ba=^?n*{QD30Q{)HPv}KdEnv}ylM8BQlmeiT{N*!tw!Yl4UZ3Kz zB@U^0p19G5UBC4P;f62m07#B+Vv?6{_?;?#h4D^jth(x zH7SgtSGSljM7W|`LKR0g512G#JJ@9NZyaYey0C^bR_JilYSXX=n}ij)RX&iElg!_? zor|I7Xxg?c7VRo04LOE%&z!~5g6oVFl|8Y-(fB5H~!xWc+v?e?n9Sbq7ktyy! zE_=Y)3QXJ>KKlAxwYfq$1u6h<+tk(jTWd%r%rLrNCak~d%o%n z1>Sm1UhEH6BbVd>lGz$6b ztE-wLnVHt#rpFPrXW0o|IUDs#rj8v@*s_lLJDm<9uV`Rs*F%`}XOmSVr8Tu9-sMSO z{ZM?<4o=wKa4=5=?#fdRyL$0lzihOXe=1x1%w%;Vm%YUz92EA$O!2_jYys&!yT4Pq zT13J9%Q~}AEN#a?pjY}f-$kvOhiy1H4S5AVMt+%+lI!hc!)1l3XZIv>1=4dB&j8;p_>_u(cM5Z_9VZ*-S!E+dVE5Q?dG zj0r9iXCv7%4wPh?OMQ!j1CvJGyJpocqFWtcGkVM+1=gBV8{KhtCgBJB#!je1b z{TAFPaA9sX=CX+?=mfwq#bi8tX4cdD;R#TgiJ9PezGnnV~zUHJ{aiqgncg#j@)HDIwO#7X4tKzwXQLCXV9?@!&tF7u^ksU0ZUB0MDz3OT0{A>h0p?| zdQPL@yjjt>cPrZCXC}7a9d;zMiQQJ8j*iw)9x+ort-%eZvtaB%|*yp6T;5n(%u;qa$3;1N=w1hg4GdJ=}Vf(90x9BmoaRHWk za|w&@!GW%QNr3@-YeT=!7qUwpy|FyGOqg7`%tcG@^oQYM> znG}tWJq`N6)u~Iy~N>59&P1Fo%~k! zJodl%+TZd=65dj_ZLE`5WgHlI=xm@Vh0CM2oVt*M)UN14z2eM;a#=yf=AU@O*qhuU z-9kwi#WU*V;40seKxc>R@6Q(7r33HH?ejEcsKqYzi@#eN#Ozl`cA`+(uN4Wa`;wae z!G1&F)`ggJoB}lLTmfDw`mT1ni#v)0Z^2(j`kng$S=J*7r#J4A| zW83|QA7j_DntGerN=xy~#5~VkAo{`+6JN+$H!c7mcnoDd=U&=& zO*DtomB{Fn-&wU-kd1S)`_!p)k{tU?d-+i5s$9iv%j>`-JNbmQmFj(+DYKu=tq*3E zgI0cF7J!y!VuB5O+kN?yKyrGh|MX4Yrnlg22(KlV+>7nTs)L7qcwM7%N}YarXsv& zz?ed@ym?^c!u_DDr@<{Yg_8A1;9+U32yo6Xo8NsO{~Y}TfXNKj_qi(ZG~69|>e}~V za_&#b3L=RzUi)~WxMHPWPj8yPe9f#o%Vn%P%P)@V*bnlu7bRH7MM>^VOrK{jLCH|< z$J)AkY;E$y@=;%}$LLp@*#*n9%BG_PWzPen%Vc2gRoRZJ>45w4Zo@A8qJ~n{+=#^s zp1UP2*Eby%%b9Im@mG)GG>X05+8=L04Wi>5^vJf2b3HJkiHbj%CWmA;*>>Yo&i*RF zbprWdvXrN;xM+0A)1XJ@bPAUXpDjk##6g{p0wR!_7H<&N!+((TpmnM7t zM-N2y$cf$3>n>IO*vS(PV3PRbqc5btOe!f}8tJRYupkvQPzNUyGv@WgPKz&Qb#A@O z!t_<@l53P*-iYuM(3ZMGkU&hYKd4~9(9AFUo~n9og${vhR1583SYoRaIi{5he0vt5xj~m=;^a@-vUyUL!8-7LkySSyA%GQP;nR2e0+3{i%RIgK283nVSitqY|jj0s=DOm}wof2=5TZzVx zI2?){HyKwq6SVyTdg1DWgx*5=n$W$AffCbw;{8VkSDTy#FQW03(kU__tNX%fG3H_L zmf{C9Rx0k{9g@;EJLGIky8f9e$*i)*92G_U@p&Nb;$Ar$mw@AWpLEywi$>%|L$Ic2 zMzy1NuZZ+d= zns^M0s#02z5LO#s5DhIsngJc_-HY(1me|=`r&AVt{PUB!oqwg8sV33#zyx!)l8 z;UOj`4cfJyp1SCdO&=XcZ0Y$Q`Y`7_$wBH7Qg&D7>}%Ixs<^PJgP#qmDlz;&I0 zAX|eM>AHXarkTnBt^Tz*n56sf2%(lIZ@M!yXl0g$?Qm2kf9*p9g3SM+45filuK3;*o+zwhT@@t8xU4}@VC%eZs;)y$I7pCE5O}la6l*>CB zp0*u@m*HZgR7oSo7RuJRq?nCY55*64=t)tWMQgjZR}65>$2`*9I(tlA6Q~`fl>_Bo z-%_`nNIUu2eARs|cSSK`X@JGFxK{{V(wnFZwfTN{@fj+?p1fa z>?~A01xdaTLg>v`Pw^uVC&iBlrvUwv6r&WYIjih4>6FrxipAR$P>j*)g|7)@TOU6zNEVE$Jvw~VR;VBcH_Nv{LDNvIlKhYk4J~9RgjwS zy6|y{p&VDw__Wf$8HArO7^5*q`6^Riv11oSU2a!Ci*rUPbtaPuVrlT_MO|b|jFvj5 z*VD)5bUGmTXO4|q?i=Tt$1A$MJ1iGNah4BxC9XE@v7A7zpDf!)hhs+eXTWxJ8qDZa*8Kznbb3LQWA`%59~+KEZc!`mo%b{ z=JlC>p@z|yNB9J++`%aM9C58VazU2I0*ZHBxzvQ0o=rXsK=GpN(YP?w{^h2Oexv*=Lg$n9>(?M$*UObx48t*79 z$y&?h+{A}=Sh)7czbpp>M9C#l<1~L7BbHv1+_+8oT<#mkPX=aYhx5PNlZ)nP+n*K* z8(4VXnlV=%cO2H6MLlgY2;|=~(2sOv470MEI&fX=6z5h|4>oI-J8Q5sR(v1y!>_h4 zwrKGcfN1^uA z`#smApwjNUA*ZoW_csgq?)!5zDI-tGf#!bwD#7={WqLGDrv~ zwwjQjVtY7NwwvWIe_=fvuXZUN*PGwH{?^~55gLSnj#*S|qsoKm>rA2+h;7;iIG)n^oumSoQ+vjI@^ zWmaUEDYVtB7p?@RVX%e%8)&(EuWlh+Pzy>kZx>&uC(em6PZF_-PRaQJ zYF@Ep9DA?;xH)L$NwA4N&f{RlfEdZqIypQ*HhnIsfz6xpajkbDCFS!+)0$CLs+F>I{{kcM(91&gr_htdri-(Us~I3`1{+|$|FDUiBN`BopB zVVJB#U3cM^>Qjq+qR#-CkYH*pm~C~*XQbwK!V; zXX#s};)^ncuSk=TTQCltaZa|k3VEUoDKMyVPVIcfPDE%{yo#~`m}4A{m2hl7?pt%5 z%f)Sn79=TT-VWkD){=wx2AaiZX{%V?(|Z)Q>ii&2O0o0RS1hb`)%zWx6@_~W{E0Xp zxpg^v8&dQ}Yo1l@b`<8>Z1Coz%Pq?aU09(Se=9A!$5@>S7FFP87B_K}5sP743u%_f zhGq33ORSj4isiCY7y{k2RTsOK(qnTrzf^X$a>oTo+?7tdyZk6yFHWj1qX{`)+EVO_ z_UO_%T$vVkIr6{?<@sQToQ>RZ`q<%$mr!fA37MId6xT|%k31i*C;T&FD(@n-QnKcc z&x7eK{@NC^4guqFOXKBcd`PvRb8a?N^80ijv*Oq@a5A~`5iy?!y>$!_pX~H($P=(j z7crNh^h}SRBrGoW>b$0)ub+Wyj~ZM>{lL^#@9-g}fX24^ z>J~nt!wfeS`sfW)pEC|A52cLKPy+s{wWMAJ;?W)q$F&MZ$$4HB`pg%^AK;I#cm z&#T=UpFyzvsygFrX7Wme{1JQkZR7bNe@xVa*0hpuOrU^>va;^^k|`Gpn6Y1k_hzNq zlG|2A&hSY6T!Cc)d(PHzobh-Bn_|Rh3!pDRSfKpm{q=-}=&?sI`y`U7)gAFGsSo~l zSnY2~Rsa(`)y_D-{He&K44hv5%{K_}$aAUUJ04_L2LI zDMx)W_6(oyt!y3%*4~Lwlb0wsG(AtXOHgz>y!*-6i4#3L++F0_s+TIIH>)&rj%rio^b1*d1onE+>q{TZS}ul^4NPc%!-a`d@~R z9tSL9L9&@2l`zRsQ_|5r>pMS^yDILGvczKc7?$VncHdfA^yy<^Z;>0JRzLFtGR1X` z93O+RIzDl;oWrm`-BJr9AB^@06m1Xys~YRd!+KJsz$&nBf@WgE{Xn?l{vpm#?qO{r46}$tQ{5n=YP`uMyjB z(!nWaN6}d;bsJA_i>{OMbGuZP(K~{`2}2U$4@y_<)iYphuXmrfaAj9y#Cc@8Z7r1a zUYz!LOdmhUr%AE^*A>B)#qR2gxk+lCM(Y)Lbq^eu#!ibDvA1S(?2*4V`aC!oSg-N% zeqPqKhgQ}9JM1jK8;X<^c-qaIweoCbj=R0! znx#Q&hjq5lpr{@pfYHBOo?z<^z{svJyomiH@|o2AJ~Q+7uM=x@w)WuM+>hyI|GE!| zioXSLy*V1kLb*ct!UE93AL`u*T3T7`5sX-=G|4HB&KWY`D0#xq3@S;->Y&`Ep_q>A z*|m2}_u{7CXR5;m6@m+s>wT0p7FwJ{%8fXa(mA!FERMjE>oSZ8Yg`TsZdh3~>T>++ZA#|dd-$XMi1Vvr&s&YRmu8K*+I-qO7_XA3{Jr(^b6pJ4YhjrM3e;SE zFIKt>WTy_^Jd*-=Ak70ThQ@_NJ#l_nZY!4X_Z4|o7hQ}Iw{~vwP9o6GqZ!sRq^Ab9 z(5U3@*AU|%!@=$nsdxDT)ju+y*)Y^mbd9dBdY*wjcV`va#nidt1`JKB7>pQIYv_8b z$vkBmgkU{BN)E)PM$J}pF(cOvzm%gw;v2RM|9T7bf%pL{jTv_@I{Z%Iiur@n>u>k> zY#P%1ZPQ5PW2FJEM!IJW+))I{cOjWQ;b)S1Tu*>#EHfRJ!BwKP*j=Z zR)}kklu1;}bs9<>fa*}|OJA1_za#UZtZ_I}XgowjwUx7l>^mFArag7>$YZ7orfje! zRa>lEn@hcak}(RcT|PJH#^`J>!~{?RXCE~o^ZTDzJihYJ=l#8Sw-6!;um%t{T-Wyj zYNP8~+DW&GD|md9Xti`ZY)UZn6VbfHqbX>udujDByFBZcn~69^M+QJ}?#{93T1V8G zfFG;pCE0A{_N#UnH?!0U#M4;fxgpaz&6c-HZmeN#7{D>pBImm^rgQ_*L*<#Mj7SQ@ zjogirLGfhIh1@O!+&;^xP@LsQ39q#x(q;{yw(x@de};_sqEJ2CFx0i=&65Tp z&Q^Z<2IDjNdmuBu45a1G(D#NZL*P}dL{u`DZ6w$-_lS6;>Qtlpb^P!t^EFp*Z=*xY z!{SK}H*RSk-RJz$N)*{|yc2%J8vovqh?WP)dCMM~k)hN-ZV3?pV4X?qpWRQS$Kl$bhwc1VEA!(|fpaxi|0iUMU&$d1YUcmSVP*Us-Tp6U%H}lsT0kzpRG+p0fRr$Zj2FEE~h+bexs|TSLhhtLbJJ;DSl`dJI2r zQ(E!9xK{RGm=ojyl-05&8Cj7NLmN?&v$46kxlS*U$RTl91@zRJF8gPSYV2&obH9TK z&mh(o!;e2K^RB}+_`ow9lukL+Z&@&6r_?Kkpf@AIFi(TLnNiWmeSz?2qU(7=?30rR zZzMV6RG6ZUy7dFKx>wh|;>6O+3G1)=E;J&Zd@ggNJK@FI^Zx_|G|#hH9hsy}dxyds zH{^l$M|`jlP5RzQdU9mb03czh|0e?^!nFS~LUGY_M*N0_I$Hyms0eU?Dq-waa_{}$ zkH6*Q>E#Kev#FXQgwFEDH;~>z;6wxEtbExU#-7CFjK7k5B}42uu3ApEU1)p+f9X+p zw4A{X&*bs8rJu+>Z0Fb>!Tnqcm^_u;R@p*OXhU4i%ShVPV)J)@YThMzcE$4fo?$z`_R**vx%xf*qdN`pdT0X@a$P!U> z885}XJGGYR)Z7}O0&|k)K*%vw$z3|x(|4VBT}vv(>QI|bBfPlRNP|2w*n0dYEbx)B zrtvV5j&13VY;6yp*oraW@{qj9{IioDJoSD5m zc`d@fjL|w>wyS~{v%AQP!}0_}YuvCu@)2*59{XFkwFr)|iV|T*Y7w8nckztNSA2FP zS4^pYTeP*IQD!D|-3qUl(U)zb{#BN!xJf@~I{|&7{-m+v#R! zzTFV%q0ICby@88~(z0d7$)Aq@zm^~0mn5kJ zc-cqxI$?^q_&455D@d{Kq_9r7@7C&Wt%XEX)^fLs^p2}}0?8rAVO%xm}J@H+rZOH13CH_!aG zSnKo^EwXAcx%%QOB(K_j?`R7xVznTPOO*kA>Xxjm*C%XDJYR++QM#ke!RJ4mQh3#L-*z&IN0>iKiJd~ z1n(1_ZF(|o@@;ujO2E!2-LJTlr7rWOmv)iG|kumH*vC9H0=NSZqK=Ht`< zB?Avh&iXrrE(9?8$}4nnmO{l`Dj7QQ428QAaM+V7bt0tQs8ulGR;f<=I#b0#{Iqd) zeY*)%K0(Rs@Zbe>vGQwA$=AzopOCz!=1PI+oUNm>+Q~Cm@+1Gy08ndIQ~6l{8=qRjy9Vuj!anx5xQvwm6f$7qcgq7hctZS);g&C|RYxi6~U(yTY*?VtF>o&(O zIW$LnETGU4>g=lhYR>Yj+&4I1pS$UuayuNZ%+Zc`?2m_p@M*B0+ly@*?-c5_BHHNU zr>TeM`87QREw|`TuTMOv@djyqOuI^Eb?yI!MsBX_JS*soSR+D2({{H-GcWH+LDtcKiZ8}#hY1iJ`}F1Xqw||5ELLkvkti8iRVLk ze86g_3AX>G8NeF4)eq3afI7;2?huGy%WP$H`sbp!-ztI|zaOZ>gUp+U$m=_)t3V+=Se9eGU=@20NA+KBj^Silof@#@_KCKjjbug z%KP-9<%ef}Yl$8-*JFmv4B{nNQGw@i+JJ|E6&`*OIF_W-dwj*^VV+~aJFjabMi2_J9P7I7(~f!^os)-waHmE0$no^Ow`_GaACbDVk68%&<ICI~cVmTpe~Pe$mQMO;uw`gH0g-tKys_qo zla7>q#ek#{2PSd+0cTz+e6%BaCmm}oXi9lJon(1zyeIg&bn>pkmNQ54_~ZJQ=!mzl z%IsQ#;Fd?<2*jgXc)swZlVH}#wG<`Qiev(tT+o9514WrpJn#SHg=<7##SuWGl34LQ zR$ur6V<4$i_r}$D6}1=M#KxF5g+I7i(Txv3Iaq$ZsRptnUf3tJGj;9Iu0I5^%0;0b zjH;DOnC2t}j1Q!=#JGVIN2YtKMcjj34O&a(8uz^j5=rT>yPb+U?${Ltkk7A{;&bUA zN1(QF#nl;UabyE-94tfTX_@ay=hRH;COMu8*j}yBYFM`E5f_OI?SDE|Nxt3#&s;g) ziqgJb>@?uY*GnzWrKmgA&ab&xP48|7e<1r=GJa!InkpYe#}(bCMBLi|uzZ|JkX>Gb zCnXer*B^2*!JVq;L(HBu+#4(=Z7va;amlSnnKi^ee79nZ*jYI=!0NTc^A+n>RrAQM##`;aa+x6Js>6)~eN82>Wmx_+K0tWgxL0obIXG`3Q!(@C913`G z$^HX!-S1b9NPuE)tQD{~35cwH1s0FDFwT;}+FPl->%3059Hkc6tk8b0$>w}cUClo*EeZY**-YRuu>(KG5S{<{cF-U$F`8eN$ zTFUK}a=Ruq<{l4r7eSGkwRI*SNNI6)8kzqATqp|+bjsKjSms?lk0fc+0y;}KDesWL z^0fRf1V7-Eph?0?3!0h_`pyvk!q(|*$KP)>o}E-Bs0sa`1R4A?##g>!JxiVM9E({K zN1?qlEd)xyRHwyG?BNy3Hs?((FTaAlrwlU2a|F3G3iX@U^inp8kRxm*gWSwFnQ(uZ z6DBT_6xGqmA|9Xk@d!W5uJfy#!G(w9T_o2wDgIw>$P^GOb^e#0dVjy#7*Z|@sIHZ- zOA_>F?fBnO(N}PmyV#k4B$GDt**0}E7D|S=kT`|o(#Y~UN@K}ZxG7f5sOakOPdvF$ zV?}7Uw%RzZ;Co8T(=GaS`$sSj!FXYJPh>oOG`H z_x5+8{%K${=y&D+_m_~$IDGcS&z&-Ii{c)5MUlCGWwLO7gVyf=YJ<;tst+t#=EQ%f z)v7R^mUFx=1oQoj)P@Du9AB2Uj63+*7g z+!C$ZQ6g145)@;mYzu6!S@(*4Z`rIBaC%Z0<$jfncW5rscWf4PK`UBDp_J@-dU?Xb zH@GCP)INhfI5Z#%jUo2C={Wn8~Jo@~v68n(E^F*X| zKwsH3C!CA2G`H4b@V0>MeD~bhlk%{YYqYW!6Usp#G9<2`7-b%jpEV_^0nTIA$yxP$ z&#XO^movg^%1F~nscHxAP>kO>^5|^(z1sEBW34|2U9C5$92yRkel7u=#<1^y#`t5Gfq%u4kz!6!es~Wr{TUh*LnN z_M3_V4o@5K*W*Suq(uc-tulO!tGM6VGKq4_UPdu%CQ{Ka4H#ow)}xTi0)Kj36X{@G(->F@u{j<9QvNNdZmE;w!? zs$AScY2)}6gJ&w8(Rq#Cos#f++Ac-M5o@D`P2*lqN>0~tS~=ZKAHinhGnG=>KMFRV zl4H-zS5+!QQ~rp>n~K@SjkcV)>Yr8X#J$0{$Vm1o7Qv8UocDvHGaSJ&CLqz6@xydh zqtq_Y8osbSUhH)TNLys>m$Uxui6!~(xiqNgP7n2%Kj@SmRzK0N;!5gbim(fvN2v`K zKQVGWod(A}h`KwJ8N0q(@QB?^%+>|mVG@9_ixcKDR;_VvoGbvFpkC_==9IoBSnxVR zY`;Q8;KJYPO;$!5InA}>HXqs_k6Bt$@fy)Vg{a(K)H_#{fEuyEL6(an@C!eIRscqE z*55BX5+vWmqayqQ{xZGmrlcfE!7I*I`M=~k2gxx1Xd81BCHxje#!BI zPi()*ecLaN8ELW!~SnAqDDHxV~PYFK=Cv!d9 za1rgs#;C=D_At3Indk9GcZ8`+70k^e=7DKz2W&%wxixNJTq zE>QfM8AB!6>;AW3YPFSV=!-=F0ro z+oV}0kR2w~fqN#Ha{BQ=evDEf_LrE>vYKCn0+`v+?RLHImp>aKV{Qz*kaml|e5dyP zLT$sTlb67*iEIBlhbqACVlrDOUU1~S1(ou11nF5-A(x`pjJJw~PXzK|x2+Rq{*K}2 zKWQA*oB2cJ#eB3h9O51R;HnY@g*JVIynA5-vmFtOkl49lZN4EnS6tt_2WAjqp`D9V zE{!efE;_m>F}jw!vW3;5C^3xq2X%Dq-n*Lb2NcVGCG6;|D>qccr;m963WEPkpOtxi zkGt%U`$Ng~!eK{6QGv}xHYD1`;C;y5wMGPAa$G;Hg(s#~UdbR-u+LP~>@!yXg<<<9 zd!fa5a-nd<{gT@QO4?G?iw#hQF7gPxCCKBIF$(&Qax>qeuSq3U&)Ddf4<-Y{)B(yw zFwQZn?Q{nFkR#b4&N3409a>y4LWxv7}nN!sQMznf((Us~u zarSQekxF4dn+soA zWF?w|CTpXzoUUD=S%NDLCANfp<~X`nq_5+;a@`;@+-ZCx=i=FqF;_+!dYZ5^CRc7Z z3v*u%s_Z&7`+M<^3c0$w?@N*f_<5R0z#3Y_ix+0gqgJKDU$Gc;U_qJWvX3U~H{A^M z)enn5l(Dr29nb&);4fgoOk3*zn_+$h-2T*pjkb=R5t$8_shJ|hAFil6u^+c<>cjhg zLPiwL)G1tFdAIQWPWOHbyvsC2&8=^-MtCkY8im^r3I-S)zP#BC${>*!0CpSx zXM*p1Df*KnSV0YkD}xlm6W;X zx2agL*`7685yd*5F7t28V%$nYD~fDvY~odX4pG!b8ho@)DX8+H-l(U7OC!obnLt2% zQuMh6cpso2^Dk`~)-L&MB>$JWZkzXaar+ehW3VbzSA7d82BrPh%{pN73N4WBq$mQ@r`%C%EmvRc?6%}(G!>7Htch&A4 z5+I3&DSvLWF{5E$>~65$)4O|moVm$8vMue$q)ks#p-GWl`c}t%uu-=iUxM!Ni86{|h6|mw>zFDn3*xUFertwD1k-n(shof43B% zU)k5NAV4=Z&>>Rv$0s7TqDd~9%XZ;QbpURbh7@WD!~+QYW6YL z7Li+%tRh@0T+F9LlQXdE!J!zDu9m{4x+J$J? zJ+A0SbOwvZdgP~^z}K(bhFz5f44L?U8A==U-Jbt;rn@^Ea(>ho#Gy7Ppb%Z%L7`z3 zHo3!uPJs2;jT*~d*QH?VXVt6^d#0|ZQhLj4_v}XcGi9+s zBci{+`&4qp3P%)iDs%h64)5w94##cffL;15WpuCu+O8aP3=G`pInz*&g|c4_(mw?f zt&9+D=|d!^*Hf8l3IVo(EB{&k8DKc_e!v@pzrV?xM{cDHdM|Mr&_sL2m$8>~QMNoT zwlD;d+teUfQq1I0p)Rp{vg3xTNG}^qONs?1xo9?Dw_GodQ&l}$H#;i9P@vadpR`}a z%oq}s^C7U4{=L^-b^m7k?X_jo63rr~@*Vm5-43^=$_POq{U7}T2=3SaOk5>n0Ai)! zj{!$zl>LWdzOjH-C3RPU_Xf54W6!`lK5k59^)zytxM!+vx`k0xJ4MW#c}~)KPrxP$ zwc`(IXdte6I#x9Hm};gQBf$;9uY#Si=JbyOkJFv=a=M{+5F4=YtZqrl-)c5ni1N`I z+cbDI)!jSy2sBy&jP!LQTTWS)fcQFPuwT6+Eb^b7b4iij1LoWiZ&r}EM=u9q~*8M}Pzlp6r9)fs_hp|a^ zR_26OtFSd$-+sb862-REA~biBgTzpH2h9rdyR;ut%_P^09f-D2{9*5&_s9+d8_+eK zT>%c`r+>AdT7`t_+J6Cz&tIUp*W(`5*Ho@!vz!yrRU}gLa=S_R|7g0(s3_YeymXh8 zv>-@_L3c?BQVU3jbh9ieA>ANSlCns{(%m2--QC?G-QVM@-=F=r=ggV7=9;C!S^Mi-7Fu5!5%kP`{WC%M{biUZvp`xv1gl?X4>nbZF zmX#O4;m}u-z6dY=%$x#m8w0CdcOv(LLxf+nMq$^U6m3pp$i#9hg?a7ea`f*d;?#Rz z&30|S*r5$j^S%_X71E(E#!A-s+DK2gi=?Lp5|@G1-$H%eq|&}IS`cvca*OQ z#Wb%w<$jT%;)5inQ2J8esJJw^Y*HXiCp)PD!UYY3gtYI4IHiery#v(r8z6avsDE{2 z2Iz?NcVQv*6oI~Q&}2Z|wwZxmHa}yc%Ewoi-h?a8fyohsatw)8&WzEDp2UG)e|va7 zihh-^exl4?_@LW<9Tsp>-}N(pp-bk>O$KFligqcvru0k37wMCmy$3F80dlCJ{gq=TZ!EnftKfpIc{wg%yI?^!dvP)_{-+E% z7PrP^pDkU9cVlUY$I!}XX3EP#cuxX31w}SpN=z8#uOd#viOO$Zj%$n<@V2iCnitQAl2nytj;N`zvx{lyW6=xU@1P}Ts`RDgUjB^^A=#}oZb1oFmYEm3xYFqjks0X zJolH8(aMiAa(Zua?cOpK=H*jt%@#$g`b$eicgHiCYRTlKh>$8Fr+8syNeO-vtqpzK zAX$Uy5}IJmz4&1j-Ki>)Lz!5*NZR?$hj;jgH|(x(JIacH^T0wws@cdcx;@J*a+|io z63>-j;0FA#kRs+AkksEyr4A|aN^>t=;i!c24 zx=L9WX$DjQs_Ir%6qgiX??VN6xhHFtw@T>p}*TM5H+PV+|3-%?&AJbJks||z7kqIApbEfIbiy3CO z!v>yEy{8N1?5KVs)qG6wIs>LM`&fdN;Ns>R(vm+`3@XQu0k|335NUWwV&B$C(># zPa?LCh!c${BbT5iasHIImNCiAQ~AGQ&pxOVu#=M66}(Rr7Yg5Og|=WVMMcT)tr|4P zBvBB~pDkT`PfXP;{^li>VA$arDhUbj)4tIrJ&AjN;S(JK96%-q5a-_r02dVK({RA{ zJ{F>nd>}@R$9E^f2+aE#o=VbqL(4HpG+L-Y!_FQNRyljnD;0)iDQd4zD(&WMmDjLa z_-gMVS$$mbmXhKVdG(J`j%MZfaNh>6g<4Z8y$iv7p2q%UXO5Lkfh6aQQX&sQ;tlx5 zWiSxYS{T5#6V|`#Q0tWT&am6OK8LfyRKH^}e0)pK;$#{ZE6b@8JJ0jP+Y?v@pCm_{XJ$DT}@!+XlzzqKJqm;uo{bA zLHBwlLr3joM$U8u+u3DHH*ZU1p`Jg_QmQJ3Px}!5E&O9c*%UD5h6emR8zH zsY^4O#OJ>KYF#@CS~-nzdm{5_4xDpTYUif|%)|4a*BY@*S8iq4b={GF4auR;ul{wb zkKLy{F!O$3?ZP#>ezxo*rdoVXMzPx zdgBuXk_h>YwVorN6u=RaycqN?SKbA^!w=fm6j*Zd)hgwM>jt?nYg*3TmG0l$nxTM` z{1W#?SpEwwL1mB=*Ky0Ct)-J{S#-s6u z^Dk^HVHsUAPbQ}4%Fj**>+^j_)lKyB`J_G*8oj#+9Su+0CKfM;BCtNsR8FAA+WVoL z%rfE8@0c0IFiNt?B&;)UIt=@u0h^)jrp%Fbx-U>m=^&C4$)43qF%wzq^`dZRk4Vqe zq%*=LSmV2)7@RwoyEEaQAOJ!-7a7P(YM=k>!*&HxoZdPUUPGmmB*wX=nDhcBr7iF4 z=|{;_p$yu&*;CPA@W@ci1uN~UjUQV*kpXAlllSZ&pMS6N2s$Zy-~vn4c-I`mv`{n7 zMh`AnQn*c@*61KJ!!MX6eV`e-XAQ%W-wM;ln3Lpr)l{1zqbq}98ni4$omxQC!jsfU ze`78Bpj^qV8Vo7MdOn;dCmd&x4Z-NLa;hz5 zcU>huZ#nL*eGq_nt2q9nxYw^!2G)V4>G9Yde87obr=8Jk`5=U#t~%EyJ?e*zM=7(% z>Bkxm+s3?!SKtP%m`d5-5l`wRH0>v!9E82^RDBwt+DMQ3nLUo)ihsg3PQNjYk9@7G zH|$80_Q_4*#(3rJ(*QN~GcZOK$yja}3-N59m$RMH_8c#AyP4Ies>7B%lWUPqQPF#s zx(kvy?VYBx;0M2c(Q`5c5Fb`Xg_a!_sFkcV_RKxw(%s3y;Tae1{y>D!G2X*xN-8Rh z*5RuQpDpF)6>D$J)B-jmwjxLoey9!gf;>0Rw6u|=;9zhH&;8FP$Fr#_6=B;SrGrEq z_YWMMQ&K7`W(KVNPXcCs<&wx~#uN;zn5%U;?cEHYRap$ygnZ;r$7N1F;!73dqfz0- znZG72nD3kxsASPQOyE!l8poJ5kfc7Rz|pdi$x}Bohfdv+=U@#fP({d~7JNB^Bp= zL4LcJW9CHQsJF}lM_j1P#SD}qJgB~HVQ4>F|4Jg+Kvz z0@3#+Ek?`TtO`kfJ)z~%t0W^@CeKf5mux($!oxJbe55etgzXvFgL$^}Oi)sROUtEl z_=X@5=qb+D;x!MaEA7()x>_Y{in_vpGUjFVyf>!8T^bQ?%;8}G+<{c;#-(Ls~l z=dTK2Wdb;Llkx<@7c~~^lQU)weohc<)1knhBSy@pw;>8@8n1L@A{0aV3z+I^>prJ^ z4Py~v+*&U*kWq1UjS75iA6h>V2AdMPj`Vp3Y%D=UKm~z(35=4NjPK`*3-t=Ie^2~4 zCNZ9!;|VNdt4FMaYg1<5)H_zatyxP}lm7nhd5Qozi$H7&QIl23*7*6t8G$k9sO8UD zj3WApw5*2)6XugMszLOcAu3mbRfit=%8UYdTL{4jghs~eGJh%i{SGQ<`ptj7 zYqW(F|nzM;XTGCBf%_w>S@cLUs%dXWfkU?I& zUdxP53>Hn`o7JUx9mO(t(2@G{R{6v%@dHX;%5+2Yget?39Pl&?QHuC z5J*#xU7X?3W;_IMsc?V=Xdcf)vo*#qRPA-#nC*U)X)iwE3{1ywdn3PWH3JMwd08Vk zzp`T{q@6U@57vn!wI=1o1t)iiCnLo>N?S6g6CB&%H&p`Z zM~NJ`Bnez*{1N^xqwKq%ylxLGbR4exL=67#w`;o-g@|jb5BIl-T=a*Jc%mhAp_T%U zWYRARAA#*raw+nU#7#b@%5NSE)$&q!$B9HmylOCZ-kzQ%KZDtQa`Y;Cu~9!f$E~^@ zS$dY=rD2D~J;|30VS9(?4VEYu zGY&XrHa{Fu5LXNjxc$VT`-o5=j@0`0&!Rty72wM!KyQO-f{0vFhj+Q6Y;u4VaLv3o4yVPL-bpHaTzX6mVwO%Pns{urGy)5VChq zwLH}HR+TgYNMPRi06p6@=4S+sz_*e#dmJx+P8IAncy6+Cb)^ODl%ac{E=1s)=>+sg z6VXcUj)4#;PtbH!xz8LPjnP(#Y5NZ>n>qz|F550gN((y)8TJKK&tWs2wyv+W6 zTtxj^+9= z%)1-yHXKedu@-lwveO!oXmIL< zr|ab$4%yN6ce?dY*X8e8LC9WSgd+!iS@u=1}usS^|wA&%Z2kq5_NYI zGHlz4y6RRbg*NUc%MyLzX2GPQ>xMlqH>FDpO??|3sIcSW#pZX%S_W5b4d?2bm1XYg zb8;)PM~|b`W`oh4nF7%cNKh2so6y0#bc z!7igY#@VY`U)~ez_rP|6Q8Bl8!eO_&Ql+$u&YVv_xupd6ntFdI$0cY`;S^_NTh7`Y z&fnm_KrfK%LI}57%BB%y=IBefOSb4QZ?OHY_6@pT8xo}>U1tm4l4w^%p%Hggu_qSS z@G9*r-L>AgqkjYbfu+fvnf<_EPOBG z8;W@DJJkQ$J^lJQecZ2!vJr<>Pr5f2(Zb)tK|N%VucQ2e%#A&}$`E?wg(ms7k!H#m z6zJ-UQ{=*aA~35GF%aOKD4or)R$XW>T{c-yEP|nf`H;EuW>qNopl{ats6cYuzGaEw zW;v;5w!@T6)Xl&MX?i;lR#_T%Kq`zqyD}L~`tl>$G6|J_k#@0R@okq?25!z#R4pf~ zS4acgPaFBvLTrv3(udOO5pzJ90A0-F`_<+F4F2&N3QP)50qKe zio2v!D8-1nz-qKQ0rT3NWyCpm#AQw1=MuiwVA0Xv754A=+a9~H{f024RmL%AX+dg4 zRq6ptJE6x4wgn#O51(5E{FkFmL*%huzMEmHbxTFJZP43T3_D;Yp8qCjl_FKRPKm&F z>glSKC6G+hi!1`cp}~y9Zz64iIZ9)qeh?){eoA|oRidrvRp<9WIA(}d9>mY+2s{reY=!R6 zpA6<68BGy8vo4cd)x6xIKJ8ZL6S>VHLk6%lM7L24J%`Dv484^|Ix_57P?*4*nT1vI z*ymfCA(YV8mZBVM85LfHXc2)6SDjy^ra)?~s$vX7ZQ1UbWD%ppbPjj>!Ujz$2E~VL z;aX2~5pA(Ra0oJ0SrYlwb5Wn^6o9wf!!p7*(RjT=3q?9N9||N7i($y^UBUrELz*4= zNb^GY{W=`H6cXQD1KN$v7tfNv5#BWg7>2<}SP+gCBvgndLjH7NW^rk<_kJIr$chvV{n3GgQHLVa?SNig=182Zoz-qRD>)>a}O{;$I4_9=mAm zQWp(#zfsMg53&W3QzU8QI+{CBj_32BlZu*c`0d^Ol*~M*7N7dSo7Pjnr`FhylU_mcvqj<8N> zaQ>Ry{gBh(1>juVKN2wjD}w3nl->szglV${FGrIJnQ(H|5N z&G7plf&B^KaPW8LuvdS5Ub;Ak+V8Q6=8xCc<_RW49Qshnjj@+mmo4NUIsF*b?Sk+Z z!eXWMOby_rd7a<;KTp8a+R9zMQW1l+k6F-(R{ZM5jd~Ax7%ywk&Tu`hF$J29OZDse zOzS>-&a-dPtBSjl<@z1qZjM#iMm5q^$5EhZNMR3ZUJ?u1FEG-q&8HYVpTcM(lAiDg z1ie#H=lo~OCT7XwN83$gpLtT2bt@V@h`@jc`w*_*;bIWxY~!-}8`l}nd)RG0ac-Mp z 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 P0DsPh-40bcP-FiOi=IS< literal 0 HcmV?d00001 diff --git a/favicon.svg b/favicon.svg deleted file mode 100644 index b785c73..0000000 --- a/favicon.svg +++ /dev/null @@ -1,19 +0,0 @@ - - - - - - - - - - - - - - - - - - - diff --git a/logo/dark.svg b/logo/dark.svg index 8b343cd..d90876d 100644 --- a/logo/dark.svg +++ b/logo/dark.svg @@ -1,21 +1,6 @@ - - - - - - - - - - - - - - - - - - - - + + + + + diff --git a/logo/light.svg b/logo/light.svg index 03e62bf..85447e8 100644 --- a/logo/light.svg +++ b/logo/light.svg @@ -1,21 +1,6 @@ - - - - - - - - - - - - - - - - - - - - + + + + +