@sandboxxjs/core 0.1.0 → 0.2.0

package/dist/index.js

@@ -7234,119 +7234,58 @@ class FileSystemError extends SandboxError {
 // src/isolators/LocalIsolator.ts
 class LocalIsolator extends Isolator {
   workDir;
-  runtime;
-  constructor(runtime = "node") {
+  constructor() {
     super();
-    this.runtime = runtime;
     this.workDir = path6.join(process.cwd(), ".sandbox", `session-${Date.now()}`);
   }
-  async execute(options) {
-    const { code, env = {}, timeout = 30000 } = options;
+  async shell(command, options = {}) {
+    const { timeout = 30000, env = {} } = options;
     const startTime = Date.now();
     await fs.mkdir(this.workDir, { recursive: true });
     try {
-      const command = this.buildCommand(code);
-      const result = await execa(command[0], command.slice(1), {
+      const result = await execa("sh", ["-c", command], {
         cwd: this.workDir,
         env: { ...process.env, ...env },
         timeout,
         maxBuffer: 10 * 1024 * 1024,
-        reject: true,
+        reject: false,
         all: true
       });
       return {
         success: result.exitCode === 0,
-        stdout: result.stdout,
-        stderr: result.stderr,
-        exitCode: result.exitCode || 0,
-        metadata: {
-          executionTime: Date.now() - startTime,
-          timestamp: new Date().toISOString()
-        }
+        stdout: result.stdout || "",
+        stderr: result.stderr || "",
+        exitCode: result.exitCode ?? 0,
+        executionTime: Date.now() - startTime
       };
     } catch (error) {
-      if (error.timedOut) {
+      if (error && typeof error === "object" && "timedOut" in error && error.timedOut) {
         throw new TimeoutError(`Execution timed out after ${timeout}ms`);
       }
-      if (error.exitCode !== undefined) {
-        return {
-          success: false,
-          stdout: error.stdout || "",
-          stderr: error.stderr || "",
-          exitCode: error.exitCode,
-          metadata: {
-            executionTime: Date.now() - startTime,
-            timestamp: new Date().toISOString()
-          }
-        };
-      }
-      throw new ExecutionError(`Execution failed: ${error.message}`);
+      throw new ExecutionError(`Shell execution failed: ${error.message}`);
     }
   }
-  buildCommand(code) {
-    switch (this.runtime) {
-      case "node":
-        return ["node", "--eval", code];
-      case "python":
-        return ["python3", "-c", code];
-      case "bash":
-        return ["bash", "-c", code];
-      default:
-        throw new ExecutionError(`Unsupported runtime: ${this.runtime}`);
+  async upload(data, remotePath) {
+    try {
+      const fullPath = path6.join(this.workDir, remotePath);
+      await fs.mkdir(path6.dirname(fullPath), { recursive: true });
+      await fs.writeFile(fullPath, data);
+    } catch (error) {
+      throw new FileSystemError(`Failed to upload file: ${error.message}`);
     }
   }
-  getFileSystem() {
-    return {
-      write: async (filePath, data) => {
-        try {
-          const fullPath = path6.join(this.workDir, filePath);
-          await fs.mkdir(path6.dirname(fullPath), { recursive: true });
-          await fs.writeFile(fullPath, data, "utf-8");
-        } catch (error) {
-          throw new FileSystemError(`Failed to write file: ${error.message}`);
-        }
-      },
-      read: async (filePath) => {
-        try {
-          const fullPath = path6.join(this.workDir, filePath);
-          return await fs.readFile(fullPath, "utf-8");
-        } catch (error) {
-          throw new FileSystemError(`Failed to read file: ${error.message}`);
-        }
-      },
-      list: async (dirPath) => {
-        try {
-          const fullPath = path6.join(this.workDir, dirPath);
-          return await fs.readdir(fullPath);
-        } catch (error) {
-          throw new FileSystemError(`Failed to list directory: ${error.message}`);
-        }
-      },
-      delete: async (filePath) => {
-        try {
-          const fullPath = path6.join(this.workDir, filePath);
-          await fs.rm(fullPath, { recursive: true, force: true });
-        } catch (error) {
-          throw new FileSystemError(`Failed to delete: ${error.message}`);
-        }
-      },
-      exists: async (filePath) => {
-        try {
-          const fullPath = path6.join(this.workDir, filePath);
-          await fs.access(fullPath);
-          return true;
-        } catch {
-          return false;
-        }
-      }
-    };
+  async download(remotePath) {
+    try {
+      const fullPath = path6.join(this.workDir, remotePath);
+      return await fs.readFile(fullPath);
+    } catch (error) {
+      throw new FileSystemError(`Failed to download file: ${error.message}`);
+    }
   }
   async destroy() {
     try {
       await fs.rm(this.workDir, { recursive: true, force: true });
-    } catch (error) {
-      console.warn(`Failed to clean up work directory: ${error.message}`);
-    }
+    } catch {}
   }
 }
 
@@ -7360,10 +7299,8 @@ class CloudflareContainerIsolator extends Isolator {
   serverProcess;
   serverUrl;
   isReady = false;
-  runtime;
-  constructor(runtime = "node") {
+  constructor() {
     super();
-    this.runtime = runtime;
   }
   async findFreePort() {
     return new Promise((resolve, reject) => {
@@ -7411,17 +7348,19 @@ class CloudflareContainerIsolator extends Isolator {
     await this.waitForReady(this.serverUrl);
     this.isReady = true;
   }
-  async execute(options) {
+  async shell(command, options = {}) {
+    const { timeout = 30000, env = {} } = options;
+    const startTime = Date.now();
     await this.ensureServerRunning();
     try {
       const response = await fetch(`${this.serverUrl}/execute`, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({
-          code: options.code,
-          runtime: this.runtime,
-          env: options.env || {},
-          timeout: options.timeout || 30000
+          code: command,
+          runtime: "bash",
+          env,
+          timeout
         })
       });
       if (!response.ok) {
@@ -7429,29 +7368,22 @@ class CloudflareContainerIsolator extends Isolator {
         throw new ExecutionError(`Server execution failed: ${error}`);
       }
       const result = await response.json();
-      return result;
+      return {
+        success: result.success,
+        stdout: result.stdout || "",
+        stderr: result.stderr || "",
+        exitCode: result.exitCode ?? (result.success ? 0 : 1),
+        executionTime: Date.now() - startTime
+      };
     } catch (error) {
-      throw new ExecutionError(`Execution failed: ${error.message}`);
+      throw new ExecutionError(`Shell execution failed: ${error.message}`);
     }
   }
-  getFileSystem() {
-    return {
-      write: async () => {
-        throw new FileSystemError("Filesystem not yet implemented for CloudflareContainerIsolator");
-      },
-      read: async () => {
-        throw new FileSystemError("Filesystem not yet implemented for CloudflareContainerIsolator");
-      },
-      list: async () => {
-        throw new FileSystemError("Filesystem not yet implemented for CloudflareContainerIsolator");
-      },
-      delete: async () => {
-        throw new FileSystemError("Filesystem not yet implemented for CloudflareContainerIsolator");
-      },
-      exists: async () => {
-        throw new FileSystemError("Filesystem not yet implemented for CloudflareContainerIsolator");
-      }
-    };
+  async upload(_data, _remotePath) {
+    throw new FileSystemError("Upload not yet implemented for CloudflareContainerIsolator");
+  }
+  async download(_remotePath) {
+    throw new FileSystemError("Download not yet implemented for CloudflareContainerIsolator");
   }
   async destroy() {
     if (this.serverProcess) {
@@ -7463,103 +7395,816 @@ class CloudflareContainerIsolator extends Isolator {
   }
 }
 
-// src/runtimes/Runtime.ts
-class Runtime {
-}
-
-// src/runtimes/GenericRuntime.ts
-class GenericRuntime extends Runtime {
-  isolator;
-  constructor(isolator) {
-    super();
-    this.isolator = isolator;
-  }
-  async execute(options) {
-    return this.isolator.execute(options);
-  }
-  async prepare() {}
-  async cleanup() {}
-}
-
 // src/Sandbox.ts
-class Sandbox {
+class BaseSandbox {
   isolator;
-  runtime;
-  eventHandlers = new Map;
-  fs;
+  config;
   constructor(config) {
-    this.isolator = this.createIsolator(config.isolator, config.runtime);
-    this.fs = this.isolator.getFileSystem();
-    this.runtime = this.createRuntime(config.runtime, this.isolator);
+    this.config = config;
+    this.isolator = this.createIsolator(config.isolator);
   }
-  createIsolator(isolatorType, runtime) {
+  createIsolator(isolatorType) {
     switch (isolatorType) {
       case "local":
-        return new LocalIsolator(runtime);
+        return new LocalIsolator;
       case "cloudflare":
-        return new CloudflareContainerIsolator(runtime);
+        return new CloudflareContainerIsolator;
       case "e2b":
-      case "firecracker":
       case "docker":
         throw new SandboxError(`Isolator "${isolatorType}" not yet implemented`);
       default:
         throw new SandboxError(`Unknown isolator type: ${isolatorType}`);
     }
   }
-  createRuntime(_runtimeType, isolator) {
-    return new GenericRuntime(isolator);
+  async shell(command) {
+    return this.isolator.shell(command, {
+      timeout: this.config.limits?.timeout
+    });
+  }
+  async upload(data, remotePath) {
+    return this.isolator.upload(data, remotePath);
+  }
+  async download(remotePath) {
+    return this.isolator.download(remotePath);
+  }
+  async destroy() {
+    return this.isolator.destroy();
+  }
+}
+// ../state/dist/index.js
+import { readFile as readFile2, writeFile as writeFile2, readdir, mkdir as mkdir2, rm as rm2, access, stat as fsStat } from "node:fs/promises";
+import { resolve, dirname as dirname2 } from "node:path";
+import { createHash } from "crypto";
+
+class StateError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "StateError";
   }
-  async execute(options) {
-    this.emit("execute:start", options);
+}
+
+class FileSystemError2 extends StateError {
+  constructor(message) {
+    super(message);
+    this.name = "FileSystemError";
+  }
+}
+
+class StateFS {
+  sandbox;
+  constructor(sandbox) {
+    this.sandbox = sandbox;
+  }
+  async read(path7) {
+    const result = await this.sandbox.shell(`cat "${path7}"`);
+    if (!result.success) {
+      throw new FileSystemError2(`Failed to read file: ${path7}`);
+    }
+    return result.stdout;
+  }
+  async write(path7, data) {
+    const dir = path7.substring(0, path7.lastIndexOf("/"));
+    if (dir) {
+      await this.sandbox.shell(`mkdir -p "${dir}"`);
+    }
+    const result = await this.sandbox.shell(`cat > "${path7}" << 'SANDBOX_EOF'
+${data}
+SANDBOX_EOF`);
+    if (!result.success) {
+      throw new FileSystemError2(`Failed to write file: ${path7}`);
+    }
+  }
+  async exists(path7) {
+    const result = await this.sandbox.shell(`test -e "${path7}" && echo "yes" || echo "no"`);
+    return result.stdout.trim() === "yes";
+  }
+  async delete(path7) {
+    await this.sandbox.shell(`rm -rf "${path7}"`);
+  }
+  async list(path7) {
+    const result = await this.sandbox.shell(`ls -1 "${path7}" 2>/dev/null`);
+    if (!result.success || !result.stdout.trim()) {
+      return [];
+    }
+    return result.stdout.trim().split(`
+`).filter(Boolean);
+  }
+}
+
+class StateEnv {
+  vars;
+  constructor(initial) {
+    this.vars = new Map(Object.entries(initial ?? {}));
+  }
+  get(key) {
+    return this.vars.get(key);
+  }
+  set(key, value) {
+    this.vars.set(key, value);
+  }
+  has(key) {
+    return this.vars.has(key);
+  }
+  delete(key) {
+    this.vars.delete(key);
+  }
+  keys() {
+    return [...this.vars.keys()];
+  }
+  all() {
+    return Object.fromEntries(this.vars);
+  }
+}
+
+class StateStorage {
+  data;
+  constructor(initial) {
+    this.data = new Map(Object.entries(initial ?? {}));
+  }
+  getItem(key) {
+    return this.data.get(key) ?? null;
+  }
+  setItem(key, value) {
+    this.data.set(key, value);
+  }
+  removeItem(key) {
+    this.data.delete(key);
+  }
+  clear() {
+    this.data.clear();
+  }
+  keys() {
+    return [...this.data.keys()];
+  }
+}
+
+class StateLog {
+  entries = [];
+  fs = {
+    write: (path7, data) => {
+      this.entries.push({ op: "fs.write", args: { path: path7, data } });
+      return this;
+    },
+    delete: (path7) => {
+      this.entries.push({ op: "fs.delete", args: { path: path7 } });
+      return this;
+    }
+  };
+  env = {
+    set: (key, value) => {
+      this.entries.push({ op: "env.set", args: { key, value } });
+      return this;
+    },
+    delete: (key) => {
+      this.entries.push({ op: "env.delete", args: { key } });
+      return this;
+    }
+  };
+  storage = {
+    set: (key, value) => {
+      this.entries.push({ op: "storage.set", args: { key, value } });
+      return this;
+    },
+    delete: (key) => {
+      this.entries.push({ op: "storage.delete", args: { key } });
+      return this;
+    },
+    clear: () => {
+      this.entries.push({ op: "storage.clear", args: {} });
+      return this;
+    }
+  };
+  recordEntry(op, args) {
+    this.entries.push({ op, args });
+    return this;
+  }
+  getEntries() {
+    return [...this.entries];
+  }
+  toJSON() {
+    return JSON.stringify(this.entries);
+  }
+  static fromJSON(json) {
+    const log = new StateLog;
+    log.entries = JSON.parse(json);
+    return log;
+  }
+  static fromEntries(entries) {
+    const log = new StateLog;
+    log.entries = [...entries];
+    return log;
+  }
+  compact() {
+    const fsState = new Map;
+    const envState = new Map;
+    const storageState = new Map;
+    let storageClear = null;
+    for (const entry of this.entries) {
+      const { op, args } = entry;
+      if (op === "fs.write") {
+        fsState.set(args.path, entry);
+      } else if (op === "fs.delete") {
+        fsState.set(args.path, entry);
+      } else if (op === "env.set") {
+        envState.set(args.key, entry);
+      } else if (op === "env.delete") {
+        envState.set(args.key, entry);
+      } else if (op === "storage.set") {
+        storageState.set(args.key, entry);
+      } else if (op === "storage.delete") {
+        storageState.set(args.key, entry);
+      } else if (op === "storage.clear") {
+        storageClear = entry;
+        storageState.clear();
+      }
+    }
+    const compactedEntries = [];
+    for (const entry of fsState.values()) {
+      compactedEntries.push(entry);
+    }
+    for (const entry of envState.values()) {
+      compactedEntries.push(entry);
+    }
+    if (storageClear) {
+      compactedEntries.push(storageClear);
+    }
+    for (const entry of storageState.values()) {
+      compactedEntries.push(entry);
+    }
+    return StateLog.fromEntries(compactedEntries);
+  }
+}
+function buildStateLog() {
+  return new StateLog;
+}
+function loadStateLog(json) {
+  return StateLog.fromJSON(json);
+}
+var opRegistry = {
+  "fs.write": {
+    namespace: "fs",
+    method: "write",
+    args: ["path", "data"],
+    replay: async (target, args) => {
+      await target.fs.write(args.path, args.data);
+    }
+  },
+  "fs.delete": {
+    namespace: "fs",
+    method: "delete",
+    args: ["path"],
+    replay: async (target, args) => {
+      await target.fs.delete(args.path);
+    }
+  },
+  "env.set": {
+    namespace: "env",
+    method: "set",
+    args: ["key", "value"],
+    replay: (target, args) => {
+      target.env.set(args.key, args.value);
+    }
+  },
+  "env.delete": {
+    namespace: "env",
+    method: "delete",
+    args: ["key"],
+    replay: (target, args) => {
+      target.env.delete(args.key);
+    }
+  },
+  "storage.set": {
+    namespace: "storage",
+    method: "setItem",
+    args: ["key", "value"],
+    replay: (target, args) => {
+      target.storage.setItem(args.key, args.value);
+    }
+  },
+  "storage.delete": {
+    namespace: "storage",
+    method: "removeItem",
+    args: ["key"],
+    replay: (target, args) => {
+      target.storage.removeItem(args.key);
+    }
+  },
+  "storage.clear": {
+    namespace: "storage",
+    method: "clear",
+    args: [],
+    replay: (target) => {
+      target.storage.clear();
+    }
+  }
+};
+function findOp(namespace, method) {
+  for (const [op, config] of Object.entries(opRegistry)) {
+    if (config.namespace === namespace && config.method === method) {
+      return op;
+    }
+  }
+  return;
+}
+function argsToEntry(op, methodArgs) {
+  const config = opRegistry[op];
+  if (!config)
+    return {};
+  const entry = {};
+  config.args.forEach((name, index) => {
+    entry[name] = methodArgs[index];
+  });
+  return entry;
+}
+async function replayStateLog(log, target) {
+  for (const entry of log.getEntries()) {
+    const config = opRegistry[entry.op];
+    if (config) {
+      await config.replay(target, entry.args);
+    }
+  }
+}
+function createRecordingProxy(target, namespace, log) {
+  return new Proxy(target, {
+    get(obj, prop) {
+      const value = obj[prop];
+      if (typeof value !== "function") {
+        return value;
+      }
+      const method = prop;
+      const op = findOp(namespace, method);
+      if (!op) {
+        return value.bind(obj);
+      }
+      return (...args) => {
+        const result = value.apply(obj, args);
+        const record = () => {
+          const entryArgs = argsToEntry(op, args);
+          log.recordEntry(op, entryArgs);
+        };
+        if (result instanceof Promise) {
+          return result.then((res) => {
+            record();
+            return res;
+          });
+        } else {
+          record();
+          return result;
+        }
+      };
+    }
+  });
+}
+function createState(options) {
+  const { sandbox, env, enableRecord } = options;
+  const baseFS = new StateFS(sandbox);
+  const baseEnv = new StateEnv(env);
+  const baseStorage = new StateStorage;
+  if (!enableRecord) {
+    return {
+      fs: baseFS,
+      env: baseEnv,
+      storage: baseStorage
+    };
+  }
+  const stateLog = buildStateLog();
+  return {
+    fs: createRecordingProxy(baseFS, "fs", stateLog),
+    env: createRecordingProxy(baseEnv, "env", stateLog),
+    storage: createRecordingProxy(baseStorage, "storage", stateLog),
+    stateLog
+  };
+}
+
+class ResourceXError extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "ResourceXError";
+  }
+}
+class TransportError extends ResourceXError {
+  transport;
+  constructor(message, transport, options) {
+    super(message, options);
+    this.transport = transport;
+    this.name = "TransportError";
+  }
+}
+
+class SemanticError extends ResourceXError {
+  semantic;
+  constructor(message, semantic, options) {
+    super(message, options);
+    this.semantic = semantic;
+    this.name = "SemanticError";
+  }
+}
+class HttpTransportHandler {
+  name;
+  protocol;
+  capabilities = {
+    canRead: true,
+    canWrite: false,
+    canList: false,
+    canDelete: false,
+    canStat: false
+  };
+  constructor(protocol = "https") {
+    this.protocol = protocol;
+    this.name = protocol;
+  }
+  async read(location) {
+    const url = `${this.protocol}://${location}`;
     try {
-      const result = await this.runtime.execute(options);
-      this.emit("execute:success", result);
-      return result;
+      const response = await fetch(url);
+      if (!response.ok) {
+        throw new TransportError(`HTTP ${response.status}: ${response.statusText} - ${url}`, this.name);
+      }
+      const arrayBuffer = await response.arrayBuffer();
+      return Buffer.from(arrayBuffer);
     } catch (error) {
-      this.emit("execute:error", error);
-      throw error;
-    } finally {
-      this.emit("execute:complete");
+      if (error instanceof TransportError) {
+        throw error;
+      }
+      throw new TransportError(`Network error: ${url}`, this.name, {
+        cause: error
+      });
     }
   }
-  async writeFile(filePath, data) {
-    return this.fs.write(filePath, data);
+}
+var httpsHandler = new HttpTransportHandler("https");
+var httpHandler = new HttpTransportHandler("http");
+
+class FileTransportHandler {
+  name = "file";
+  capabilities = {
+    canRead: true,
+    canWrite: true,
+    canList: true,
+    canDelete: true,
+    canStat: true
+  };
+  resolvePath(location) {
+    return resolve(process.cwd(), location);
   }
-  async readFile(filePath) {
-    return this.fs.read(filePath);
+  async read(location) {
+    const filePath = this.resolvePath(location);
+    try {
+      return await readFile2(filePath);
+    } catch (error) {
+      const err = error;
+      throw new TransportError(`File read error: ${err.code} - ${filePath}`, this.name, {
+        cause: err
+      });
+    }
   }
-  async destroy() {
-    await this.runtime.cleanup();
-    await this.isolator.destroy();
-    this.eventHandlers.clear();
+  async write(location, content) {
+    const filePath = this.resolvePath(location);
+    try {
+      await mkdir2(dirname2(filePath), { recursive: true });
+      await writeFile2(filePath, content);
+    } catch (error) {
+      const err = error;
+      throw new TransportError(`File write error: ${err.code} - ${filePath}`, this.name, {
+        cause: err
+      });
+    }
   }
-  on(event, handler) {
-    if (!this.eventHandlers.has(event)) {
-      this.eventHandlers.set(event, []);
+  async list(location) {
+    const dirPath = this.resolvePath(location);
+    try {
+      return await readdir(dirPath);
+    } catch (error) {
+      const err = error;
+      throw new TransportError(`Directory list error: ${err.code} - ${dirPath}`, this.name, {
+        cause: err
+      });
     }
-    this.eventHandlers.get(event).push(handler);
   }
-  emit(event, ...args) {
-    const handlers = this.eventHandlers.get(event);
-    if (handlers) {
-      for (const handler of handlers) {
-        handler(...args);
-      }
+  async mkdir(location) {
+    const dirPath = this.resolvePath(location);
+    try {
+      await mkdir2(dirPath, { recursive: true });
+    } catch (error) {
+      const err = error;
+      throw new TransportError(`Directory create error: ${err.code} - ${dirPath}`, this.name, {
+        cause: err
+      });
+    }
+  }
+  async exists(location) {
+    const filePath = this.resolvePath(location);
+    try {
+      await access(filePath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async stat(location) {
+    const filePath = this.resolvePath(location);
+    try {
+      const stats = await fsStat(filePath);
+      return {
+        size: stats.size,
+        modifiedAt: stats.mtime,
+        isDirectory: stats.isDirectory()
+      };
+    } catch (error) {
+      const err = error;
+      throw new TransportError(`File stat error: ${err.code} - ${filePath}`, this.name, {
+        cause: err
+      });
+    }
+  }
+  async delete(location) {
+    const filePath = this.resolvePath(location);
+    try {
+      await rm2(filePath, { recursive: true });
+    } catch (error) {
+      const err = error;
+      throw new TransportError(`File delete error: ${err.code} - ${filePath}`, this.name, {
+        cause: err
+      });
+    }
+  }
+}
+var fileHandler = new FileTransportHandler;
+var handlers = new Map([
+  ["https", httpsHandler],
+  ["http", httpHandler],
+  ["file", fileHandler]
+]);
+class TextSemanticHandler {
+  name = "text";
+  async resolve(transport, location, context) {
+    const buffer = await transport.read(location);
+    const text = buffer.toString("utf-8");
+    const meta = {
+      url: context.url,
+      semantic: context.semantic,
+      transport: context.transport,
+      location: context.location,
+      size: buffer.length,
+      encoding: "utf-8",
+      mimeType: "text/plain",
+      resolvedAt: context.timestamp.toISOString()
+    };
+    return {
+      type: "text",
+      content: text,
+      meta
+    };
+  }
+  async deposit(transport, location, data, _context) {
+    if (!transport.write) {
+      throw new SemanticError(`Transport "${transport.name}" does not support write operation`, this.name);
+    }
+    const buffer = Buffer.from(data, "utf-8");
+    await transport.write(location, buffer);
+  }
+  async exists(transport, location, _context) {
+    if (transport.exists) {
+      return transport.exists(location);
     }
+    try {
+      await transport.read(location);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async delete(transport, location, _context) {
+    if (!transport.delete) {
+      throw new SemanticError(`Transport "${transport.name}" does not support delete operation`, this.name);
+    }
+    await transport.delete(location);
+  }
+}
+var textHandler = new TextSemanticHandler;
+function toBuffer(data) {
+  if (Buffer.isBuffer(data)) {
+    return data;
+  }
+  if (data instanceof Uint8Array) {
+    return Buffer.from(data);
+  }
+  if (data instanceof ArrayBuffer) {
+    return Buffer.from(data);
+  }
+  if (Array.isArray(data)) {
+    return Buffer.from(data);
+  }
+  throw new SemanticError(`Unsupported binary input type`, "binary");
+}
+
+class BinarySemanticHandler {
+  name = "binary";
+  async resolve(transport, location, context) {
+    const buffer = await transport.read(location);
+    const meta = {
+      url: context.url,
+      semantic: context.semantic,
+      transport: context.transport,
+      location: context.location,
+      size: buffer.length,
+      resolvedAt: context.timestamp.toISOString()
+    };
+    return {
+      type: "binary",
+      content: buffer,
+      meta
+    };
+  }
+  async deposit(transport, location, data, _context) {
+    if (!transport.write) {
+      throw new SemanticError(`Transport "${transport.name}" does not support write operation`, this.name);
+    }
+    const buffer = toBuffer(data);
+    await transport.write(location, buffer);
+  }
+  async exists(transport, location, _context) {
+    if (transport.exists) {
+      return transport.exists(location);
+    }
+    try {
+      await transport.read(location);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async delete(transport, location, _context) {
+    if (!transport.delete) {
+      throw new SemanticError(`Transport "${transport.name}" does not support delete operation`, this.name);
+    }
+    await transport.delete(location);
+  }
+}
+var binaryHandler = new BinarySemanticHandler;
+var handlers2 = new Map([
+  ["text", textHandler],
+  ["binary", binaryHandler]
+]);
+class MemoryStateStore {
+  logs = new Map;
+  blobs = new Map;
+  async saveLog(key, data) {
+    this.logs.set(key, data);
+  }
+  async loadLog(key) {
+    return this.logs.get(key) ?? null;
+  }
+  async deleteLog(key) {
+    this.logs.delete(key);
+  }
+  async listLogs() {
+    return [...this.logs.keys()];
   }
+  async saveBlob(ref, data) {
+    this.blobs.set(ref, data);
+  }
+  async loadBlob(ref) {
+    return this.blobs.get(ref) ?? null;
+  }
+  async deleteBlob(ref) {
+    this.blobs.delete(ref);
+  }
+}
+function generateRef(data) {
+  const hash = createHash("sha256").update(data).digest("hex");
+  return `sha256-${hash}`;
+}
+
+class StateAssetsImpl {
+  sandbox;
+  store;
+  uploadedPaths = new Set;
+  constructor(options) {
+    this.sandbox = options.sandbox;
+    this.store = options.store;
+  }
+  async uploadBuffer(data, remotePath) {
+    const ref = generateRef(data);
+    await this.sandbox.upload(data, remotePath);
+    await this.store.saveBlob(ref, data);
+    this.uploadedPaths.add(remotePath);
+    return ref;
+  }
+  async downloadBuffer(remotePath, options) {
+    const data = await this.sandbox.download(remotePath);
+    if (options?.persist) {
+      const ref = generateRef(data);
+      await this.store.saveBlob(ref, data);
+      return ref;
+    }
+    return data;
+  }
+  list() {
+    return [...this.uploadedPaths];
+  }
+}
+// src/mixins/withState.ts
+function withState(Base) {
+  return class extends Base {
+    fs;
+    env;
+    storage;
+    stateLog;
+    constructor(config) {
+      super(config);
+      const stateConfig = config.state;
+      const state = createState({
+        sandbox: this,
+        env: stateConfig?.env,
+        enableRecord: stateConfig?.enableRecord
+      });
+      this.fs = state.fs;
+      this.env = state.env;
+      this.storage = state.storage;
+      this.stateLog = state.stateLog;
+      if (stateConfig?.initializeLog) {
+        replayStateLog(stateConfig.initializeLog, this);
+      }
+    }
+    getStateLog() {
+      return this.stateLog;
+    }
+  };
+}
+// src/mixins/withNodeExecute.ts
+function withNodeExecute(Base) {
+  return class extends Base {
+    nodeChecked = false;
+    constructor(config) {
+      super(config);
+    }
+    async execute(code) {
+      if (!this.nodeChecked) {
+        const check = await this.shell("which node");
+        if (!check.success) {
+          throw new ExecutionError("Node.js is not installed. Please install Node.js or use a different isolator (cloudflare/e2b).");
+        }
+        this.nodeChecked = true;
+      }
+      const escapedCode = code.replace(/'/g, "'\\''");
+      const result = await this.shell(`node -e '${escapedCode}'`);
+      return {
+        success: result.success,
+        stdout: result.stdout,
+        stderr: result.stderr,
+        exitCode: result.exitCode,
+        executionTime: result.executionTime
+      };
+    }
+  };
+}
+// src/mixins/withPythonExecute.ts
+function withPythonExecute(Base) {
+  return class extends Base {
+    pythonChecked = false;
+    constructor(config) {
+      super(config);
+    }
+    async execute(code) {
+      if (!this.pythonChecked) {
+        const check = await this.shell("which python3");
+        if (!check.success) {
+          throw new ExecutionError("Python 3 is not installed. Please install Python 3 or use a different isolator (cloudflare/e2b).");
+        }
+        this.pythonChecked = true;
+      }
+      const escapedCode = code.replace(/'/g, "'\\''");
+      const result = await this.shell(`python3 -c '${escapedCode}'`);
+      return {
+        success: result.success,
+        stdout: result.stdout,
+        stderr: result.stderr,
+        exitCode: result.exitCode,
+        executionTime: result.executionTime
+      };
+    }
+  };
 }
 export {
+  withState,
+  withPythonExecute,
+  withNodeExecute,
+  loadStateLog,
+  buildStateLog,
   TimeoutError,
+  StateStorage,
+  StateFS,
+  StateError,
+  StateEnv,
   SandboxError,
-  Sandbox,
-  Runtime,
   LocalIsolator,
   Isolator,
   IsolationError,
-  GenericRuntime,
-  FileSystemError,
+  FileSystemError2 as FileSystemError,
   ExecutionError,
-  CloudflareContainerIsolator
+  CloudflareContainerIsolator,
+  BaseSandbox
 };
 
-//# debugId=09D6DD78D2CFDED564756E2164756E21
+//# debugId=7693E135F99AC4E664756E2164756E21