@cloudflare/sandbox 0.0.0-1a42464 → 0.0.0-1be7d53

package/README.md

@@ -17,6 +17,10 @@
   - [Basic Setup](#basic-setup)
 - [📚 API Reference](#api-reference)
   - [Core Methods](#core-methods)
+- [🧪 Code Interpreter](#code-interpreter)
+  - [Code Execution](#code-execution)
+  - [Rich Outputs](#rich-outputs)
+  - [Output Formats](#output-formats)
 - [🌐 Port Forwarding](#port-forwarding)
   - [Utility Methods](#utility-methods)
 - [💡 Examples](#examples)
@@ -24,6 +28,7 @@
   - [Build and Test Code](#build-and-test-code)
   - [Interactive Development Environment](#interactive-development-environment)
   - [Expose Services with Preview URLs](#expose-services-with-preview-urls)
+  - [Data Analysis with Code Interpreter](#data-analysis-with-code-interpreter)
 - [🏗️ Architecture](#architecture)
 - [🛠️ Advanced Usage](#advanced-usage)
   - [AsyncIterable Streaming Support](#asynciterable-streaming-support)
@@ -45,11 +50,15 @@ The Cloudflare Sandbox SDK enables you to run isolated code environments directl
 - **🔒 Secure Isolation**: Each sandbox runs in its own container with full process isolation
 - **⚡ Edge-Native**: Runs on Cloudflare's global network for low latency worldwide
 - **📁 File System Access**: Read, write, and manage files within the sandbox
+- **🖼️ Binary File Support**: Automatic MIME type detection and base64 encoding for images, PDFs, and other binary files
 - **🔧 Command Execution**: Run any command or process inside the container
 - **🌐 Preview URLs**: Expose services running in your sandbox via public URLs
 - **🔄 Git Integration**: Clone repositories directly into sandboxes
-- **🚀 Streaming Support**: Real-time output streaming for long-running commands
+- **🚀 Streaming Support**: Real-time output streaming for long-running commands and file transfers
 - **🎮 Session Management**: Maintain state across multiple operations
+- **🧪 Code Interpreter**: Execute Python and JavaScript with rich outputs (charts, tables, formatted data)
+- **📊 Multi-Language Support**: Persistent execution contexts for Python and JavaScript/TypeScript
+- **🎨 Rich MIME Types**: Automatic processing of images, HTML, charts, and structured data
 
 <h2 id="quick-start">🚀 Quick Start</h2>
 
@@ -64,12 +73,10 @@ npm install @cloudflare/sandbox
 1. **Create a Dockerfile** (temporary requirement, will be removed in future releases):
 
 ```dockerfile
-FROM docker.io/cloudflare/sandbox:0.1.2
+FROM docker.io/cloudflare/sandbox:0.3.6
 
+# Expose the ports you want to expose
 EXPOSE 3000
-
-# Run the same command as the original image
-CMD ["bun", "index.ts"]
 ```
 
 2. **Configure wrangler.json**:
@@ -83,7 +90,7 @@ CMD ["bun", "index.ts"]
     {
       "class_name": "Sandbox",
       "image": "./Dockerfile",
-      "max_instances": 1
+      "max_instances": 20
     }
   ],
   "durable_objects": {
@@ -178,16 +185,62 @@ for await (const log of parseSSEStream<LogEvent>(logStream)) {
 Write content to a file.
 
 ```typescript
-await sandbox.writeFile("/app.js", "console.log('Hello!');");
+await sandbox.writeFile("/workspace/app.js", "console.log('Hello!');");
 ```
 
 #### `readFile(path, options?)`
 
-Read a file from the sandbox.
+Read a file from the sandbox with automatic binary detection.
 
 ```typescript
+// Read text files
 const file = await sandbox.readFile("/package.json");
-console.log(file.content);
+console.log(file.content); // UTF-8 text content
+
+// Read binary files - automatically detected and base64 encoded
+const image = await sandbox.readFile("/workspace/chart.png");
+console.log(image.mimeType); // "image/png"
+console.log(image.isBinary); // true
+console.log(image.encoding); // "base64"
+console.log(image.size); // File size in bytes
+
+// Use the base64 content directly in data URLs
+const dataUrl = `data:${image.mimeType};base64,${image.content}`;
+```
+
+#### `readFileStream(path)`
+
+Stream large files efficiently with automatic chunking and encoding.
+
+```typescript
+import { streamFile, collectFile } from '@cloudflare/sandbox';
+
+// Stream a large file
+const stream = await sandbox.readFileStream("/large-video.mp4");
+
+// Option 1: Process chunks as they arrive
+for await (const chunk of streamFile(stream)) {
+  if (chunk instanceof Uint8Array) {
+    // Binary chunk - already decoded from base64
+    console.log(`Received ${chunk.byteLength} bytes`);
+    // Process binary data...
+  } else {
+    // Text chunk
+    console.log('Text:', chunk);
+  }
+}
+
+// Option 2: Collect entire file into memory
+const { content, metadata } = await collectFile(stream);
+console.log(`MIME: ${metadata.mimeType}, Size: ${metadata.size} bytes`);
+
+if (content instanceof Uint8Array) {
+  // Binary file - ready to save or process
+  await writeToStorage(content);
+} else {
+  // Text file
+  console.log('Content:', content);
+}
 ```
 
 #### `gitCheckout(repoUrl, options?)`
@@ -235,7 +288,8 @@ console.log(result.stdout); // "production"
 #### File System Methods
 
 - `writeFile(path, content, options?)` - Write content to a file
-- `readFile(path, options?)` - Read a file from the sandbox
+- `readFile(path, options?)` - Read a file with automatic binary detection and base64 encoding
+- `readFileStream(path)` - Stream large files efficiently with chunking
 - `mkdir(path, options?)` - Create a directory
 - `deleteFile(path)` - Delete a file
 - `renameFile(oldPath, newPath)` - Rename a file
@@ -248,6 +302,131 @@ console.log(result.stdout); // "production"
 - `unexposePort(port)` - Remove port exposure
 - `getExposedPorts()` - List all exposed ports with their URLs
 
+#### Session Methods
+
+- `createSession(options)` - Create an isolated execution session
+  - `name`: Session identifier
+  - `env`: Environment variables for this session
+  - `cwd`: Working directory
+  - `isolation`: Enable PID namespace isolation (requires CAP_SYS_ADMIN)
+
+<h2 id="code-interpreter">🧪 Code Interpreter</h2>
+
+The Sandbox SDK includes powerful code interpreter capabilities, allowing you to execute Python and JavaScript code with rich outputs including charts, tables, and formatted data.
+
+### Code Execution
+
+#### `createCodeContext(options?)`
+
+Creates a new code execution context with persistent state.
+
+```typescript
+// Create a Python context
+const pythonCtx = await sandbox.createCodeContext({ language: 'python' });
+
+// Create a JavaScript context
+const jsCtx = await sandbox.createCodeContext({ language: 'javascript' });
+```
+
+**Options:**
+- `language`: Programming language (`'python'` | `'javascript'` | `'typescript'`)
+- `cwd`: Working directory (default: `/workspace`)
+- `envVars`: Environment variables for the context
+
+#### `runCode(code, options?)`
+
+Executes code with optional streaming callbacks.
+
+```typescript
+// Simple execution
+const execution = await sandbox.runCode('print("Hello World")', { 
+  context: pythonCtx 
+});
+
+// With streaming callbacks
+await sandbox.runCode(`
+for i in range(5):
+    print(f"Step {i}")
+    time.sleep(1)
+`, { 
+  context: pythonCtx,
+  onStdout: (output) => console.log('Real-time:', output.text),
+  onResult: (result) => console.log('Result:', result)
+});
+```
+
+**Options:**
+- `context`: Context to run the code in
+- `language`: Language if no context provided
+- `onStdout`: Callback for stdout output
+- `onStderr`: Callback for stderr output
+- `onResult`: Callback for execution results
+- `onError`: Callback for errors
+
+#### `runCodeStream(code, options?)`
+
+Returns a streaming response for real-time processing.
+
+```typescript
+const stream = await sandbox.runCodeStream('import time; [print(i) for i in range(10)]');
+// Process the stream as needed
+```
+
+### Rich Outputs
+
+The code interpreter automatically detects and processes various output types:
+
+```typescript
+// Data visualization
+const execution = await sandbox.runCode(`
+import matplotlib.pyplot as plt
+import numpy as np
+
+x = np.linspace(0, 10, 100)
+y = np.sin(x)
+plt.plot(x, y)
+plt.title('Sine Wave')
+plt.show()
+`, { 
+  context: pythonCtx,
+  onResult: (result) => {
+    if (result.png) {
+      // Base64 encoded PNG image
+      console.log('Chart generated!');
+    }
+  }
+});
+
+// HTML tables with pandas
+const tableExecution = await sandbox.runCode(`
+import pandas as pd
+df = pd.DataFrame({
+    'name': ['Alice', 'Bob', 'Charlie'],
+    'score': [92, 88, 95]
+})
+df
+`, { context: pythonCtx });
+
+// Access HTML table in execution.results[0].html
+```
+
+### Output Formats
+
+Results can include multiple formats:
+- `text`: Plain text representation
+- `html`: HTML (often pandas DataFrames)
+- `png`/`jpeg`: Base64 encoded images
+- `svg`: Vector graphics
+- `json`: Structured data
+- `chart`: Parsed chart information
+
+Check available formats with `result.formats()`.
+
+#### Additional Code Interpreter Methods
+
+- `listCodeContexts()` - List all active code contexts
+- `deleteCodeContext(contextId)` - Delete a specific context
+
 <h2 id="port-forwarding">🌐 Port Forwarding</h2>
 
 The SDK automatically handles preview URL routing for exposed ports. Just add one line to your worker:
@@ -284,7 +463,7 @@ The SDK handles:
 
 ```dockerfile
 # In your Dockerfile (only needed for local dev)
-FROM oven/bun:latest
+FROM docker.io/cloudflare/sandbox:0.1.3
 
 # Expose the ports you'll be using
 EXPOSE 3000  # For a web server
@@ -316,7 +495,7 @@ const sandbox = getSandbox(env.Sandbox, "node-app");
 
 // Write a simple Express server
 await sandbox.writeFile(
-  "/app.js",
+  "/workspace/app.js",
   `
   const express = require('express');
   const app = express();
@@ -406,14 +585,100 @@ console.log(`Service available at: ${preview.url}`);
 // See the example in examples/basic/src/index.ts for the routing implementation.
 ```
 
+### Data Analysis with Code Interpreter
+
+```typescript
+const sandbox = getSandbox(env.Sandbox, "analysis");
+
+// Create a Python context for data analysis
+const pythonCtx = await sandbox.createCodeContext({ language: 'python' });
+
+// Load and analyze data
+const analysis = await sandbox.runCode(`
+import pandas as pd
+import matplotlib.pyplot as plt
+
+# Create sample data
+data = {
+    'Month': ['Jan', 'Feb', 'Mar', 'Apr', 'May'],
+    'Sales': [10000, 12000, 15000, 14000, 18000],
+    'Profit': [2000, 2500, 3200, 2800, 4000]
+}
+df = pd.DataFrame(data)
+
+# Display summary statistics
+print("Sales Summary:")
+print(df.describe())
+
+# Create visualization
+plt.figure(figsize=(10, 6))
+plt.subplot(1, 2, 1)
+plt.bar(df['Month'], df['Sales'])
+plt.title('Monthly Sales')
+plt.xlabel('Month')
+plt.ylabel('Sales ($)')
+
+plt.subplot(1, 2, 2)
+plt.plot(df['Month'], df['Profit'], marker='o', color='green')
+plt.title('Monthly Profit')
+plt.xlabel('Month')
+plt.ylabel('Profit ($)')
+
+plt.tight_layout()
+plt.show()
+
+# Return the data as JSON
+df.to_dict('records')
+`, { 
+  context: pythonCtx,
+  onResult: (result) => {
+    if (result.png) {
+      // Handle the chart image
+      console.log('Chart generated:', result.png.substring(0, 50) + '...');
+    }
+    if (result.json) {
+      // Handle the structured data
+      console.log('Data:', result.json);
+    }
+  }
+});
+
+// Multi-language workflow: Process in Python, analyze in JavaScript
+await sandbox.runCode(`
+# Save processed data
+df.to_json('/tmp/sales_data.json', orient='records')
+`, { context: pythonCtx });
+
+const jsCtx = await sandbox.createCodeContext({ language: 'javascript' });
+const jsAnalysis = await sandbox.runCode(`
+const fs = require('fs');
+const data = JSON.parse(fs.readFileSync('/tmp/sales_data.json', 'utf8'));
+
+// Calculate growth rate
+const growth = data.map((curr, idx) => {
+  if (idx === 0) return { ...curr, growth: 0 };
+  const prev = data[idx - 1];
+  return {
+    ...curr,
+    growth: ((curr.Sales - prev.Sales) / prev.Sales * 100).toFixed(2) + '%'
+  };
+});
+
+console.log('Growth Analysis:', growth);
+growth;
+`, { context: jsCtx });
+```
+
 <h2 id="architecture">🏗️ Architecture</h2>
 
 The SDK leverages Cloudflare's infrastructure:
 
 - **Durable Objects**: Manages sandbox lifecycle and state
-- **Containers**: Provides isolated execution environments
+- **Containers**: Provides isolated execution environments with Jupyter kernels
 - **Workers**: Handles HTTP routing and API interface
 - **Edge Network**: Enables global distribution and low latency
+- **Jupyter Integration**: Python (IPython) and JavaScript (TSLab) kernels for code execution
+- **MIME Processing**: Automatic detection and handling of rich output formats
 
 <h2 id="advanced-usage">🛠️ Advanced Usage</h2>
 
@@ -448,10 +713,15 @@ for await (const event of parseSSEStream<ExecEvent>(stream)) {
 
 The SDK exports utilities for working with Server-Sent Event streams:
 
+**Command Execution:**
 - **`parseSSEStream<T>(stream)`** - Convert ReadableStream to typed AsyncIterable
 - **`responseToAsyncIterable<T>(response)`** - Convert SSE Response to AsyncIterable
 - **`asyncIterableToSSEStream<T>(iterable)`** - Convert AsyncIterable back to SSE stream
 
+**File Streaming:**
+- **`streamFile(stream, signal?)`** - Convert file SSE stream to AsyncIterable with automatic base64 decoding
+- **`collectFile(stream, signal?)`** - Collect entire file from stream into memory
+
 #### Advanced Streaming Examples
 
 **CI/CD Build System:**
@@ -494,17 +764,71 @@ for await (const log of parseSSEStream<LogEvent>(logStream)) {
 
 ### Session Management
 
-Maintain context across commands:
+The SDK provides two approaches for managing execution context:
+
+#### Implicit Sessions (Recommended)
+
+Each sandbox maintains its own persistent session automatically:
+
+```typescript
+const sandbox = getSandbox(env.Sandbox, "my-app");
+
+// These commands share state (pwd, env vars, etc.)
+await sandbox.exec("cd /app");
+await sandbox.exec("pwd");  // Output: /app
+await sandbox.exec("export MY_VAR=hello");
+await sandbox.exec("echo $MY_VAR");  // Output: hello
+```
+
+#### Explicit Sessions for Advanced Use Cases
+
+Create isolated execution contexts within the same sandbox:
 
 ```typescript
-const sessionId = crypto.randomUUID();
+const sandbox = getSandbox(env.Sandbox, "multi-env");
+
+// Create independent sessions with different environments
+const buildSession = await sandbox.createSession({
+  name: "build",
+  env: { NODE_ENV: "production" },
+  cwd: "/build"
+});
 
-// Commands in the same session share working directory
-await sandbox.exec("cd /app", { sessionId });
-await sandbox.exec("npm install", { sessionId });
-const app = await sandbox.startProcess("npm start", { sessionId });
+const testSession = await sandbox.createSession({
+  name: "test",
+  env: { NODE_ENV: "test" },
+  cwd: "/test"
+});
+
+// Run commands in parallel with different contexts
+await Promise.all([
+  buildSession.exec("npm run build"),
+  testSession.exec("npm test")
+]);
 ```
 
+#### Security with AI Agents
+
+When using AI coding agents, separate development from execution:
+
+```typescript
+// Phase 1: AI agent writes code (with API keys)
+const devSession = await sandbox.createSession({
+  name: "ai-development",
+  env: { ANTHROPIC_API_KEY: process.env.ANTHROPIC_API_KEY }
+});
+await devSession.exec('opencode "build a web server"');
+
+// Phase 2: Run the generated code (without API keys)
+const appSession = await sandbox.createSession({
+  name: "app-runtime",
+  env: { PORT: "3000" }  // Only app-specific vars
+});
+await appSession.exec("node server.js");
+```
+
+> **Best Practice**: Keep AI agent credentials separate from your application runtime to prevent accidental exposure of API keys.
+
 <h2 id="debugging">🔍 Debugging</h2>
 
 Enable verbose logging:
@@ -523,6 +847,9 @@ sandbox.client.onCommandComplete = (success, code) =>
 - Maximum container runtime is limited by Durable Object constraints
 - WebSocket support for preview URLs coming soon
 - Some system calls may be restricted in the container environment
+- Code interpreter has no internet access (sandbox restriction)
+- Some Python/JavaScript packages may not be pre-installed
+- Resource limits apply to code execution (CPU, memory)
 
 <h2 id="contributing">🤝 Contributing</h2>
 
@@ -536,11 +863,21 @@ cd sandbox-sdk
 # Install dependencies
 npm install
 
+# Install Bun (if not already installed)
+# Visit https://bun.sh for installation instructions
+curl -fsSL https://bun.sh/install | bash
+
+# Install container dependencies (required for TypeScript checking)
+cd packages/sandbox/container_src && bun install && cd -
+
 # Run tests
 npm test
 
 # Build the project
 npm run build
+
+# Run type checking and linting
+npm run check
 ```
 
 <h2 id="license">📄 License</h2>

package/container_src/bun.lock

@@ -0,0 +1,76 @@
+{
+  "lockfileVersion": 1,
+  "workspaces": {
+    "": {
+      "name": "sandbox-server",
+      "dependencies": {
+        "esbuild": "^0.21.5",
+        "uuid": "^9.0.1",
+      },
+      "devDependencies": {
+        "@types/node": "^20.0.0",
+        "@types/uuid": "^9.0.7",
+        "typescript": "^5.3.0",
+      },
+    },
+  },
+  "packages": {
+    "@esbuild/aix-ppc64": ["@esbuild/aix-ppc64@0.21.5", "", { "os": "aix", "cpu": "ppc64" }, "sha512-1SDgH6ZSPTlggy1yI6+Dbkiz8xzpHJEVAlF/AM1tHPLsf5STom9rwtjE4hKAF20FfXXNTFqEYXyJNWh1GiZedQ=="],
+
+    "@esbuild/android-arm": ["@esbuild/android-arm@0.21.5", "", { "os": "android", "cpu": "arm" }, "sha512-vCPvzSjpPHEi1siZdlvAlsPxXl7WbOVUBBAowWug4rJHb68Ox8KualB+1ocNvT5fjv6wpkX6o/iEpbDrf68zcg=="],
+
+    "@esbuild/android-arm64": ["@esbuild/android-arm64@0.21.5", "", { "os": "android", "cpu": "arm64" }, "sha512-c0uX9VAUBQ7dTDCjq+wdyGLowMdtR/GoC2U5IYk/7D1H1JYC0qseD7+11iMP2mRLN9RcCMRcjC4YMclCzGwS/A=="],
+
+    "@esbuild/android-x64": ["@esbuild/android-x64@0.21.5", "", { "os": "android", "cpu": "x64" }, "sha512-D7aPRUUNHRBwHxzxRvp856rjUHRFW1SdQATKXH2hqA0kAZb1hKmi02OpYRacl0TxIGz/ZmXWlbZgjwWYaCakTA=="],
+
+    "@esbuild/darwin-arm64": ["@esbuild/darwin-arm64@0.21.5", "", { "os": "darwin", "cpu": "arm64" }, "sha512-DwqXqZyuk5AiWWf3UfLiRDJ5EDd49zg6O9wclZ7kUMv2WRFr4HKjXp/5t8JZ11QbQfUS6/cRCKGwYhtNAY88kQ=="],
+
+    "@esbuild/darwin-x64": ["@esbuild/darwin-x64@0.21.5", "", { "os": "darwin", "cpu": "x64" }, "sha512-se/JjF8NlmKVG4kNIuyWMV/22ZaerB+qaSi5MdrXtd6R08kvs2qCN4C09miupktDitvh8jRFflwGFBQcxZRjbw=="],
+
+    "@esbuild/freebsd-arm64": ["@esbuild/freebsd-arm64@0.21.5", "", { "os": "freebsd", "cpu": "arm64" }, "sha512-5JcRxxRDUJLX8JXp/wcBCy3pENnCgBR9bN6JsY4OmhfUtIHe3ZW0mawA7+RDAcMLrMIZaf03NlQiX9DGyB8h4g=="],
+
+    "@esbuild/freebsd-x64": ["@esbuild/freebsd-x64@0.21.5", "", { "os": "freebsd", "cpu": "x64" }, "sha512-J95kNBj1zkbMXtHVH29bBriQygMXqoVQOQYA+ISs0/2l3T9/kj42ow2mpqerRBxDJnmkUDCaQT/dfNXWX/ZZCQ=="],
+
+    "@esbuild/linux-arm": ["@esbuild/linux-arm@0.21.5", "", { "os": "linux", "cpu": "arm" }, "sha512-bPb5AHZtbeNGjCKVZ9UGqGwo8EUu4cLq68E95A53KlxAPRmUyYv2D6F0uUI65XisGOL1hBP5mTronbgo+0bFcA=="],
+
+    "@esbuild/linux-arm64": ["@esbuild/linux-arm64@0.21.5", "", { "os": "linux", "cpu": "arm64" }, "sha512-ibKvmyYzKsBeX8d8I7MH/TMfWDXBF3db4qM6sy+7re0YXya+K1cem3on9XgdT2EQGMu4hQyZhan7TeQ8XkGp4Q=="],
+
+    "@esbuild/linux-ia32": ["@esbuild/linux-ia32@0.21.5", "", { "os": "linux", "cpu": "ia32" }, "sha512-YvjXDqLRqPDl2dvRODYmmhz4rPeVKYvppfGYKSNGdyZkA01046pLWyRKKI3ax8fbJoK5QbxblURkwK/MWY18Tg=="],
+
+    "@esbuild/linux-loong64": ["@esbuild/linux-loong64@0.21.5", "", { "os": "linux", "cpu": "none" }, "sha512-uHf1BmMG8qEvzdrzAqg2SIG/02+4/DHB6a9Kbya0XDvwDEKCoC8ZRWI5JJvNdUjtciBGFQ5PuBlpEOXQj+JQSg=="],
+
+    "@esbuild/linux-mips64el": ["@esbuild/linux-mips64el@0.21.5", "", { "os": "linux", "cpu": "none" }, "sha512-IajOmO+KJK23bj52dFSNCMsz1QP1DqM6cwLUv3W1QwyxkyIWecfafnI555fvSGqEKwjMXVLokcV5ygHW5b3Jbg=="],
+
+    "@esbuild/linux-ppc64": ["@esbuild/linux-ppc64@0.21.5", "", { "os": "linux", "cpu": "ppc64" }, "sha512-1hHV/Z4OEfMwpLO8rp7CvlhBDnjsC3CttJXIhBi+5Aj5r+MBvy4egg7wCbe//hSsT+RvDAG7s81tAvpL2XAE4w=="],
+
+    "@esbuild/linux-riscv64": ["@esbuild/linux-riscv64@0.21.5", "", { "os": "linux", "cpu": "none" }, "sha512-2HdXDMd9GMgTGrPWnJzP2ALSokE/0O5HhTUvWIbD3YdjME8JwvSCnNGBnTThKGEB91OZhzrJ4qIIxk/SBmyDDA=="],
+
+    "@esbuild/linux-s390x": ["@esbuild/linux-s390x@0.21.5", "", { "os": "linux", "cpu": "s390x" }, "sha512-zus5sxzqBJD3eXxwvjN1yQkRepANgxE9lgOW2qLnmr8ikMTphkjgXu1HR01K4FJg8h1kEEDAqDcZQtbrRnB41A=="],
+
+    "@esbuild/linux-x64": ["@esbuild/linux-x64@0.21.5", "", { "os": "linux", "cpu": "x64" }, "sha512-1rYdTpyv03iycF1+BhzrzQJCdOuAOtaqHTWJZCWvijKD2N5Xu0TtVC8/+1faWqcP9iBCWOmjmhoH94dH82BxPQ=="],
+
+    "@esbuild/netbsd-x64": ["@esbuild/netbsd-x64@0.21.5", "", { "os": "none", "cpu": "x64" }, "sha512-Woi2MXzXjMULccIwMnLciyZH4nCIMpWQAs049KEeMvOcNADVxo0UBIQPfSmxB3CWKedngg7sWZdLvLczpe0tLg=="],
+
+    "@esbuild/openbsd-x64": ["@esbuild/openbsd-x64@0.21.5", "", { "os": "openbsd", "cpu": "x64" }, "sha512-HLNNw99xsvx12lFBUwoT8EVCsSvRNDVxNpjZ7bPn947b8gJPzeHWyNVhFsaerc0n3TsbOINvRP2byTZ5LKezow=="],
+
+    "@esbuild/sunos-x64": ["@esbuild/sunos-x64@0.21.5", "", { "os": "sunos", "cpu": "x64" }, "sha512-6+gjmFpfy0BHU5Tpptkuh8+uw3mnrvgs+dSPQXQOv3ekbordwnzTVEb4qnIvQcYXq6gzkyTnoZ9dZG+D4garKg=="],
+
+    "@esbuild/win32-arm64": ["@esbuild/win32-arm64@0.21.5", "", { "os": "win32", "cpu": "arm64" }, "sha512-Z0gOTd75VvXqyq7nsl93zwahcTROgqvuAcYDUr+vOv8uHhNSKROyU961kgtCD1e95IqPKSQKH7tBTslnS3tA8A=="],
+
+    "@esbuild/win32-ia32": ["@esbuild/win32-ia32@0.21.5", "", { "os": "win32", "cpu": "ia32" }, "sha512-SWXFF1CL2RVNMaVs+BBClwtfZSvDgtL//G/smwAc5oVK/UPu2Gu9tIaRgFmYFFKrmg3SyAjSrElf0TiJ1v8fYA=="],
+
+    "@esbuild/win32-x64": ["@esbuild/win32-x64@0.21.5", "", { "os": "win32", "cpu": "x64" }, "sha512-tQd/1efJuzPC6rCFwEvLtci/xNFcTZknmXs98FYDfGE4wP9ClFV98nyKrzJKVPMhdDnjzLhdUyMX4PsQAPjwIw=="],
+
+    "@types/node": ["@types/node@20.19.16", "", { "dependencies": { "undici-types": "~6.21.0" } }, "sha512-VS6TTONVdgwJwtJr7U+ghEjpfmQdqehLLpg/iMYGOd1+ilaFjdBJwFuPggJ4EAYPDCzWfDUHoIxyVnu+tOWVuQ=="],
+
+    "@types/uuid": ["@types/uuid@9.0.8", "", {}, "sha512-jg+97EGIcY9AGHJJRaaPVgetKDsrTgbRjQ5Msgjh/DQKEFl0DtyRr/VCOyD1T2R1MNeWPK/u7JoGhlDZnKBAfA=="],
+
+    "esbuild": ["esbuild@0.21.5", "", { "optionalDependencies": { "@esbuild/aix-ppc64": "0.21.5", "@esbuild/android-arm": "0.21.5", "@esbuild/android-arm64": "0.21.5", "@esbuild/android-x64": "0.21.5", "@esbuild/darwin-arm64": "0.21.5", "@esbuild/darwin-x64": "0.21.5", "@esbuild/freebsd-arm64": "0.21.5", "@esbuild/freebsd-x64": "0.21.5", "@esbuild/linux-arm": "0.21.5", "@esbuild/linux-arm64": "0.21.5", "@esbuild/linux-ia32": "0.21.5", "@esbuild/linux-loong64": "0.21.5", "@esbuild/linux-mips64el": "0.21.5", "@esbuild/linux-ppc64": "0.21.5", "@esbuild/linux-riscv64": "0.21.5", "@esbuild/linux-s390x": "0.21.5", "@esbuild/linux-x64": "0.21.5", "@esbuild/netbsd-x64": "0.21.5", "@esbuild/openbsd-x64": "0.21.5", "@esbuild/sunos-x64": "0.21.5", "@esbuild/win32-arm64": "0.21.5", "@esbuild/win32-ia32": "0.21.5", "@esbuild/win32-x64": "0.21.5" }, "bin": { "esbuild": "bin/esbuild" } }, "sha512-mg3OPMV4hXywwpoDxu3Qda5xCKQi+vCTZq8S9J/EpkhB2HzKXq4SNFZE3+NK93JYxc8VMSep+lOUSC/RVKaBqw=="],
+
+    "typescript": ["typescript@5.9.2", "", { "bin": { "tsc": "bin/tsc", "tsserver": "bin/tsserver" } }, "sha512-CWBzXQrc/qOkhidw1OzBTQuYRbfyxDXJMVJ1XNwUHGROVmuaeiEm3OslpZ1RV96d7SKKjZKrSJu3+t/xlw3R9A=="],
+
+    "undici-types": ["undici-types@6.21.0", "", {}, "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ=="],
+
+    "uuid": ["uuid@9.0.1", "", { "bin": { "uuid": "dist/bin/uuid" } }, "sha512-b+1eJOlsR9K8HJpow9Ok3fiWOWSIcIzXodvv0rQjVoOVNpWMpxf1wZNpt4y9h10odCNrqnYp1OBzRktckBe3sA=="],
+  }
+}